Method, system and program product for specifying a configuration for multiple signal or dial instances in a digital system

ABSTRACT

A digital system includes a plurality of hierarchically arranged design entity instantiations including a first entity instantiation containing second and third instantiations of the same design entity. Each of the instantiations contains a respective instance of a configurable entity having a plurality of possible configuration values that each corresponds to a different configuration of a functional portion of the digital system. A configuration specification for the digital system is received including a Dial containing a mapping between each of a plurality of possible Dial input values and a respective one of a plurality of configuration values. The configuration specification generically refers to the design entity. In response to receipt of the configuration specification, both instance of the configurable entity are automatically located. In response to the instances of the configurable entity, an association between the mapping and each of the instances of the configurable entity is automatically created.

CROSS-REFERENCE TO RELATED APPLICATIONS

[0001] The present application is related to the following co-pendingU.S. patent applications filed on even date herewith:

[0002] (1) U.S. Patent Application Serial No. 10/______ ,______(AUS920030005US1);

[0003] (2) U.S. Patent Application Serial No. 10/______ ,______(AUS920030006US1);

[0004] (3) U.S. Patent Application Serial No. 10/______ ,______(AUS920030007US1);

[0005] (4) U.S. Patent Application Serial No. 10/______ ,______(AUS920030008US1);

[0006] (5) U.S. Patent Application Serial No. 10/______ ,______(AUS920030009US1);

[0007] (6) U.S. Patent Application Serial No. 10/______ ,______(AUS920030106US1);

[0008] (7) U.S. Patent Application Serial No. 10/______ ,______(AUS920030107US1);

[0009] (8) U.S. Patent Application Serial No. 10/______ ,______(AUS920030108US1);

[0010] (9) U.S. Patent Application Serial No. 10/______ ,______(AUS920030110US1);

[0011] (10) U.S. Patent Application Serial No. 10/______ ,______(AUS920030111US1); and

[0012] (11) U.S. Patent Application Serial No. 10/______ ,______(AUS920030191US1).

[0013] All of the above-mentioned patent applications are assigned tothe assignee of the present invention and incorporated herein byreference in their entireties.

BACKGROUND OF THE INVENTION

[0014] 1. Technical Field

[0015] The present invention relates in general to designing, simulatingand configuring digital devices, modules and systems, and in particular,to methods and systems for computer-aided design, simulation, andconfiguration of digital devices, modules and systems described by ahardware description language (HDL) model.

[0016] 2. Description of the Related Art

[0017] In a typical digital design process, verifying the logicalcorrectness of a digital design and debugging the design (if necessary)are important steps of the design process performed prior to developinga circuit layout. Although it is certainly possible to test a digitaldesign by actually building the digital design, digital designs,particularly those implemented by integrated circuitry, are typicallyverified and debugged by simulating the digital design on a computer,due in part to the time and expense required for integrated circuitfabrication.

[0018] In a typical automated design process, a circuit designer entersinto an electronic computer-aided design (ECAD) system a high-leveldescription of the digital design to be simulated utilizing a hardwaredescription language (HDL), such as VHDL, thus producing a digitalrepresentation of the various circuit blocks and their interconnections.In the digital representation, the overall circuit design is frequentlydivided into smaller parts, hereinafter referred to as design entities,which are individually designed, often by different designers, and thencombined in a hierarchical manner to create an overall model. Thishierarchical design technique is very useful in managing the enormouscomplexity of the overall design and facilitates error detection duringsimulation.

[0019] The ECAD system compiles the digital representation of the designinto a simulation model having a format best suited for simulation. Asimulator then exercises the simulation model to detect logical errorsin the digital design.

[0020] A simulator is typically a software tool that operates on thesimulation model by applying a list of input stimuli representing inputsof the digital system. The simulator generates a numericalrepresentation of the response of the circuit to the input stimuli,which response may then either be viewed on the display screen as a listof values or further interpreted, often by a separate software program,and presented on the display screen in graphical form. The simulator maybe run either on a general-purpose computer or on another piece ofelectronic apparatus specially designed for simulation. Simulators thatrun entirely in software on a general-purpose computer are referred toas “software simulators,” and simulators that run with the assistance ofspecially designed electronic apparatus are referred to as “hardwaresimulators.”

[0021] As digital designs have become increasingly complex, digitaldesigns are commonly simulated at several levels of abstraction, forexample, at functional, logical and circuit levels. At the functionallevel, system operation is described in terms of a sequence oftransactions between registers, adders, memories and other functionalunits. Simulation at the functional level is utilized to verify thehigh-level design of digital systems. At the logical level, a digitalsystem is described in terms of logic elements such as logic gates andflip-flops. Simulation at the logical level is utilized to verify thecorrectness of the logic design. At the circuit level, each logic gateis described in terms of its circuit components such as transistors,impedances, capacitances, and other such devices. Simulation at thecircuit level provides detailed information about voltage levels andswitching speeds.

[0022] In order to verify the results of any given simulation run,custom-developed programs written in high-level languages such as C orC++, referred to as a reference model, are written to process inputstimuli (also referred to as test vectors) to produce expected resultsof the simulation run. The test vector is then run against thesimulation execution model by the simulator. The results of thesimulation run are then compared to the results predicted by thereference model to detect discrepancies, which are flagged as errors.Such a simulation check is known in the verification art as an“end-to-end” check.

[0023] In modem data processing systems, especially large server-classcomputer systems, the number of latches that must be loaded to configurethe system for operation (or simulation) is increasing dramatically. Onereason for the increase in configuration latches is that many chips arebeing designed to support multiple different configurations andoperating modes in order to improve manufacturer profit margins andsimplify system design. For example, memory controllers commonly requiresubstantial configuration information to properly interface memory cardsof different types, sizes, and operating frequencies.

[0024] A second reason for the increase in configuration latches is theever-increasing transistor budget within processors and other integratedcircuit chips. Often the additional transistors available within thenext generation of chips are devoted to replicated copies of existingfunctional units in order to improve fault tolerance and parallelism.However, because transmission latency via intra-chip wiring is notdecreasing proportionally to the increase in the operating frequency offunctional logic, it is generally viewed as undesirable to centralizeconfiguration latches for all similar functional units. Consequently,even though all instances of a replicated functional unit are frequentlyidentically configured, each instance tends to be designed with its owncopy of the configuration latches. Thus, configuring an operatingparameter having only a few valid values (e.g., the ratio between thebus clock frequency and processor clock frequency) may involve settinghundreds of configuration latches in a processor chip.

[0025] Conventionally, configuration latches and their permitted rangeof values have been specified by error-prone paper documentation that istedious to create and maintain. Compounding the difficulty inmaintaining accurate configuration documentation and the effort requiredto set configuration latches is the fact that different constituencieswithin a single company (e.g., a functional simulation team, alaboratory debug team, and one or more customer firmware teams) oftenseparately develop configuration software from the configurationdocumentation. As the configuration software is separately developed byeach constituency, each team may introduce its own errors and employ itsown terminology and naming conventions. Consequently, the configurationsoftware developed by the different teams is not compatible and cannoteasily be shared between the different teams.

[0026] In addition to the foregoing shortcomings in the process ofdeveloping configuration code, conventional configuration software isextremely tedious to code. In particular, the vocabulary used todocument the various configuration bits is often quite cumbersome. Forexample, in at least some implementations, configuration code mustspecify, for each configuration latch bit, a full latch name, which mayinclude fifty or more ASCII characters. In addition, valid binary bitpatterns for each group of configuration latches must be individuallyspecified.

[0027] In view of the foregoing, the present invention appreciates thatit would be useful and desirable to provide an improved method ofconfiguring a digital system described by an HDL model, particularly onethat permits configuration information to be specified in a logicalmanner with a reasonable amount of input and then shared among thevarious organizational constituencies involved in the design,simulation, and commercial implementation of the digital system.

SUMMARY OF THE INVENTION

[0028] Improved methods, systems, and program products for specifyingthe configuration of a digital system, such as an integrated circuit orcollection of interconnected integrated circuits, are disclosed.According to one embodiment, a digital system includes a plurality ofhierarchically arranged design entity instantiations including a firstentity instantiation containing second and third instantiations of thesame design entity. Each of the instantiations contains a respectiveinstance of a configurable entity having a plurality of possibleconfiguration values that each corresponds to a different configurationof a functional portion of the digital system. A configurationspecification for the digital system is received including a Dialcontaining a mapping between each of a plurality of possible Dial inputvalues and a respective one of a plurality of configuration values. Theconfiguration specification generically refers to the design entity. Inresponse to receipt of the configuration specification, both instance ofthe configurable entity are automatically located. In response to theinstances of the configurable entity, an association between the mappingand each of the instances of the configurable entity is automaticallycreated.

[0029] All objects, features, and advantages of the present inventionwill become apparent in the following detailed written description.

BRIEF DESCRIPTION OF THE DRAWINGS

[0030] The novel features believed characteristic of the invention areset forth in the appended claims. However, the invention, as well as apreferred mode of use, will best be understood by reference to thefollowing detailed description of an illustrative embodiment when readin conjunction with the accompanying drawings, wherein:

[0031]FIG. 1 is a high level block diagram of a data processing systemthat may be utilized to implement the present invention;

[0032]FIG. 2 is a diagrammatic representation of a design entitydescribed by HDL code;

[0033]FIG. 3 illustrates an exemplary digital design including aplurality of hierarchically arranged design entities;

[0034]FIG. 4A depicts an exemplary HDL file including embeddedconfiguration specification statements in accordance with the presentinvention;

[0035]FIG. 4B illustrates an exemplary HDL file including an embeddedconfiguration file reference statement referring to an externalconfiguration file containing a configuration specification statement inaccordance with the present invention;

[0036]FIG. 5A is a diagrammatic representation of an LDial primitive inaccordance with the present invention

[0037]FIG. 5B depicts an exemplary digital design including a pluralityof hierarchically arranged design entities in which LDials areinstantiated in accordance with the present invention;

[0038]FIG. 5C illustrates an exemplary digital design including aplurality of hierarchically arranged design entities in which an LDialis employed to configure signal states at multiple different levels ofthe design hierarchy;

[0039]FIG. 5D is a diagrammatic representation of a Switch in accordancewith the present invention;

[0040]FIG. 6A is a diagrammatic representation of an IDial in accordancewith the present invention;

[0041]FIG. 6B is a diagrammatic representation of an IDial having asplit output in accordance with the present invention;

[0042]FIG. 7A is a diagrammatic representation of a CDial employed tocontrol other Dials in accordance with the present invention;

[0043]FIG. 7B depicts an exemplary digital design including a pluralityof hierarchically arranged design entities in which a CDial is employedto control lower-level Dials utilized to configure signal states;

[0044]FIG. 8 is a high level flow diagram of a model build processutilized to produce a simulation executable model and associatedsimulation configuration database in accordance with the presentinvention;

[0045]FIG. 9A illustrates a portion of a digital design illustrating themanner in which a traceback process implemented by a configurationcompiler detects inverters in the signal path between a configuredsignal and an associated configuration latch;

[0046]FIG. 9B is a high level flowchart of an exemplary tracebackprocess implemented by a configuration compiler in accordance with apreferred embodiment of the present invention;

[0047]FIG. 10 is a high level logical flowchart of an exemplary methodby which a configuration compiler parses each signal or Dialidentification within a configuration specification statement inaccordance with a preferred embodiment of the present invention;

[0048]FIG. 11A depicts a diagrammatic representation of a Dial group;

[0049]FIG. 11B illustrates an exemplary simulation model including Dialsgrouped in multiple hierarchically arranged Dial groups;

[0050]FIG. 12 depicts an exemplary embodiment of a simulationconfiguration database in accordance with the present invention;

[0051]FIG. 13 is a high level logical flowchart of a illustrative methodby which a configuration database is expanded within volatile memory ofa data processing system in accordance with the present invention;

[0052]FIG. 14 is a block diagram depicting the contents of volatilesystem memory during a simulation run of a simulation model inaccordance with the present invention;

[0053]FIG. 15 is a high level logical flowchart of an exemplary methodof locating one or more Dial instance data structure (DIDS) in aconfiguration database that are identified by a instance qualifier anddialname qualifier supplied in an API call;

[0054]FIG. 16A is a high level logical flowchart of an illustrativemethod of reading a Dial instance in an interactive mode duringsimulation of a digital design in accordance with the present invention;

[0055]FIG. 16B is a high level logical flowchart of an exemplary methodof reading a Dial group instance in an interactive mode duringsimulation of a digital design in accordance with the present invention;

[0056]FIG. 17A is a high level logical flowchart of an illustrativemethod of setting a Dial instance in an interactive mode duringsimulation of a digital design in accordance with the present invention;

[0057]FIG. 17B is a high level logical flowchart of an exemplary methodof setting a Dial group instance in an interactive mode duringsimulation of a digital design in accordance with the present invention;

[0058]FIG. 18 is a high level logical flowchart of an illustrativemethod of setting a Dial instance or Dial group instance in a batch modeduring simulation of a digital design in accordance with the presentinvention;

[0059]FIG. 19 is a block diagram depicting an exemplary laboratorytesting system in accordance with the present invention;

[0060]FIG. 20 is a more detailed block diagram of an integrated circuitchip within a data processing system forming a portion of the laboratorytesting system of FIG. 19;

[0061]FIG. 21 is a high level flow diagram of an illustrative processfor transforming a simulation configuration database to obtain a chiphardware database suitable for use in configuring a hardware realizationof a digital design;

[0062]FIG. 22A is a high level logical flowchart of an exemplary methodof transforming a configuration database to obtain a chip hardwaredatabase in accordance with the present invention;

[0063]FIG. 22B depicts an illustrative embodiment of a latch datastructure within a chip hardware database following the transformationprocess illustrated in FIG. 22A;

[0064]FIG. 23A is a high level logical flowchart of an exemplary methodof loading a hardware configuration database from non-volatile storageinto volatile memory that supports use of the hardware configurationdatabase with digital systems of any arbitrary size or configuration;

[0065]FIG. 23B illustrates an exemplary embodiment of a hardwareconfiguration database of a digital system in accordance with oneembodiment of the present invention;

[0066]FIG. 24 is a high level logical flowchart of an exemplary methodof identifying, by reference to a hardware configuration database, oneor more Dial instances or Dial group instances in a digital system thatare relevant to an API call;

[0067]FIG. 25 is a high level logical flow diagram of an exemplaryprocess by which a hardware configuration database developed duringlaboratory development and testing of system firmware can be compressedfor commercial deployment;

[0068]FIGS. 26A-26C together form a high level logical flowchart of anillustrative method of compressing a hardware configuration databaseutilizing a software compression tool in accordance with the presentinvention;

[0069]FIG. 27 is a graphical representation of the contents of anexemplary configuration database including both Dials and read-onlyDials in accordance with the present invention;

[0070]FIGS. 28A-28B respectively illustrate the inclusion of read-onlyparent fields within Dial instance data structures and latch datastructures of a configuration database in order to support read-onlyDials and read-only Dial groups in accordance with one embodiment of thepresent invention;

[0071]FIG. 29 is a high level logical flowchart of an exemplary methodof expanding a configuration database containing RDial and/or RDialgroups into volatile memory;

[0072]FIG. 30 is a high level flow diagram of an exemplary process foranalyzing a selected state of a hardware system, and in particular, afailure state of a hardware system, in accordance with the presentinvention; and

[0073]FIG. 31 is a high level logical flowchart of an exemplary methodby which the chip analyzer tool of FIG. 30 generates chip configurationreports and simulation setup files utilized to analyze hardware failuresin accordance with the present invention.

DETAILED DESCRIPTION OF ILLUSTRATIVE EMBODIMENT

[0074] The present invention introduces a configuration specificationlanguage and associated methods, systems, and program products forconfiguring and controlling the setup of a digital system (e.g., one ormore integrated circuits or a simulation model thereof). In at least oneembodiment, configuration specifications for signals in the digitalsystem are created in HDL code by the designer responsible for anassociated design entity. Thus, designers at the front end of the designprocess, who are best able to specify the signal names and associatedlegal values, are responsible for creating the configurationspecification. The configuration specification is compiled at modelbuild time together with the HDL describing the digital system to obtaina configuration database that can then be utilized by downstreamorganizational groups involved in the design, simulation, and hardwareimplementation processes.

[0075] With reference now to the figures, and in particular withreference to FIG. 1, there is depicted an exemplary embodiment of a dataprocessing system in accordance with the present invention. The depictedembodiment can be realized, for example, as a workstation, server, ormainframe computer.

[0076] As illustrated, data processing system 6 includes one or moreprocessing nodes 8 a-8 n, which, if more than one processing node 8 isimplemented, are interconnected by node interconnect 22. Processingnodes 8 a-8 n may each include one or more processors 10, a localinterconnect 16, and a system memory 18 that is accessed via a memorycontroller 17. Processors 10 a-10 m are preferably (but not necessarily)identical and may comprise a processor within the PowerPC™ line ofprocessors available from International Business Machines (IBM)Corporation of Armonk, N.Y. In addition to the registers, instructionflow logic and execution units utilized to execute program instructions,which are generally designated as processor core 12, each of processors10 a-10 m also includes an on-chip cache hierarchy that is utilized tostage data to the associated processor core 12 from system memories 18.

[0077] Each of processing nodes 8 a-8 n further includes a respectivenode controller 20 coupled between local interconnect 16 and nodeinterconnect 22. Each node controller 20 serves as a local agent forremote processing nodes 8 by performing at least two functions. First,each node controller 20 snoops the associated local interconnect 16 andfacilitates the transmission of local communication transactions toremote processing nodes 8. Second, each node controller 20 snoopscommunication transactions on node interconnect 22 and masters relevantcommunication transactions on the associated local interconnect 16.Communication on each local interconnect 16 is controlled by an arbiter24. Arbiters 24 regulate access to local interconnects 16 based on busrequest signals generated by processors 10 and compile coherencyresponses for snooped communication transactions on local interconnects16.

[0078] Local interconnect 16 is coupled, via mezzanine bus bridge 26, toa mezzanine bus 30. Mezzanine bus bridge 26 provides both a low latencypath through which processors 10 may directly access devices among I/Odevices 32 and storage devices 34 that are mapped to bus memory and/orI/O address spaces and a high bandwidth path through which I/O devices32 and storage devices 34 may access system memory 18. I/O devices 32may include, for example, a display device, a keyboard, a graphicalpointer, and serial and parallel ports for connection to externalnetworks or attached devices. Storage devices 34 may include, forexample, optical or magnetic disks that provide non-volatile storage foroperating system, middleware and application software. In the presentembodiment, such application software includes an ECAD system 35, whichcan be utilized to develop, verify and simulate a digital circuit designin accordance with the methods and systems of the present invention.

[0079] Simulated digital circuit design models created utilizing ECADsystem 35 are comprised of at least one, and usually many, sub-unitsreferred to hereinafter as design entities. Referring now to FIG. 2,there is illustrated a block diagram representation of an exemplarydesign entity 200 which may be created utilizing ECAD system 35. Designentity 200 is defined by a number of components: an entity name, entityports, and a representation of the function performed by design entity200. Each design entity within a given model has a unique entity name(not explicitly shown in FIG. 2) that is declared in the HDL descriptionof the design entity. Furthermore, each design entity typically containsa number of signal interconnections, known as ports, to signals outsidethe design entity. These outside signals may be primary input/outputs(I/Os) of an overall design or signals connected to other designentities within an overall design.

[0080] Typically, ports are categorized as belonging to one of threedistinct types: input ports, output ports, and bi-directional ports.Design entity 200 is depicted as having a number of input ports 202 thatconvey signals into design entity 200. Input ports 202 are connected toinput signals 204. In addition, design entity 200 includes a number ofoutput ports 206 that convey signals out of design entity 200. Outputports 206 are connected to a set of output signals 208. Bi-directionalports 210 are utilized to convey signals into and out of design entity200. Bi-directional ports 210 are in turn connected to a set ofbidirectional signals 212. A design entity, such as design entity 200,need not contain ports of all three types, and in the degenerate case,contains no ports at all. To accomplish the connection of entity portsto external signals, a mapping technique, known as a “port map”, isutilized. A port map (not explicitly depicted in FIG. 2) consists of aspecified correspondence between entity port names and external signalsto which the entity is connected. When building a simulation model, ECADsoftware 35 is utilized to connect external signals to appropriate portsof the entity according to a port map specification.

[0081] As further illustrated in FIG. 2, design entity 200 contains abody section 214 that describes one or more functions performed bydesign entity 200. In the case of a digital design, body section 214contains an interconnection of logic gates, storage elements, etc., inaddition to instantiations of other entities. By instantiating an entitywithin another entity, a hierarchical description of an overall designis achieved. For example, a microprocessor may contain multipleinstances of an identical functional unit. As such, the microprocessoritself will often be modeled as a single entity. Within themicroprocessor entity, multiple instantiations of any duplicatedfunctional entities will be present.

[0082] Each design entity is specified by one or more HDL files thatcontain the information necessary to describe the design entity.Although not required by the present invention, it will hereafter beassumed for ease of understanding that each design entity is specifiedby a respective HDL file.

[0083] With reference now to FIG. 3, there is illustrated a diagrammaticrepresentation of an exemplary simulation model 300 that may be employedby ECAD system 35 to represent a digital design (e.g., an integratedcircuit chip or a computer system) in a preferred embodiment of thepresent invention. For visual simplicity and clarity, the ports andsignals interconnecting the design entities within simulation model 300have not been explicitly shown.

[0084] Simulation model 300 includes a number of hierarchically arrangeddesign entities. As within any simulation model, simulation model 300includes one and only one “top-level entity” encompassing all otherentities within simulation model 300. That is to say, top-level entity302 instantiates, either directly or indirectly, all descendant entitieswithin the digital design. Specifically, top-level entity 302 directlyinstantiates (i.e., is the direct ancestor of) two instances, 304 a and304 b, of the same FiXed-point execution Unit (FXU) entity 304 and asingle instance of a Floating Point Unit (FPU) entity 314. FXU entityinstances 304, having instantiation names FXU0 and FXU1, respectively,in turn instantiate additional design entities, including multipleinstantiations of entity A 306 having instantiation names A0 and A1,respectively.

[0085] Each instantiation of a design entity has an associateddescription that contains an entity name and an instantiation name,which must be unique among all descendants of the direct ancestorentity, if any. For example, top-level entity 302 has a description 320including an entity name 322 (i.e., the “TOP” preceding the colon) andalso includes an instantiation name 324 (i.e., the “TOP” following thecolon). Within an entity description, it is common for the entity nameto match the instantiation name when only one instance of thatparticular entity is instantiated within the ancestor entity. Forexample, single instances of entity B 310 and entity C 312 instantiatedwithin each of FXU entity instantiations 304 a and 304 b have matchingentity and instantiation names. However, this naming convention is notrequired by the present invention as shown by FPU entity 314 (i.e., theinstantiation name is FPU0, while the entity name is FPU).

[0086] The nesting of entities within other entities in a digital designcan continue to an arbitrary level of complexity, provided that allentities instantiated, whether singly or multiply, have unique entitynames and the instantiation names of all descendant entities within anydirect ancestor entity are unique with respect to one another.

[0087] Associated with each design entity instantiation is a so called“instantiation identifier”. The instantiation identifier for a giveninstantiation is a string including the enclosing entity instantiationnames proceeding from the top-level entity instantiation name. Forexample, the design instantiation identifier of instantiation 312 a ofentity C 312 within instantiation 304 a of FXU entity 304 is“TOP.FXU0.B.C”. This instantiation identifier serves to uniquelyidentify each instantiation within a simulation model.

[0088] As discussed above, a digital design, whether realized utilizingphysical integrated circuitry or as a software model such as simulationmodel 300, typically includes configuration latches utilized toconfigure the digital design for proper operation. In contrast to priorart design methodologies, which employ stand-alone configurationsoftware created after a design is realized to load values into theconfiguration latches, the present invention introduces a configurationspecification language that permits a digital designer to specifyconfiguration values for signals as a natural part of the designprocess. In particular, the configuration specification language of thepresent invention permits a design configuration to be specifiedutilizing statements either embedded in one or more HDL files specifyingthe digital design (as illustrated in FIG. 4A) or in one or moreexternal configuration files referenced by the one or more HDL filesspecifying the digital design (as depicted in FIG. 4B).

[0089] Referring now to FIG. 4A, there is depicted an exemplary HDL file400, in this case a VHDL file, including embedded configurationstatements in accordance with the present invention. In this example,HDL file 400 specifies entity A 306 of simulation model 300 and includesthree sections of VHDL code, namely, a port list 402 that specifiesports 202, 206 and 210, signal declarations 404 that specify the signalswithin body section 214, and a design specification 406 that specifiesthe logic and functionality of body section 214. Interspersed withinthese sections are conventional VHDL comments denoted by an initialdouble-dash (“--”). In addition, embedded within design specification406 are one or more configuration specification statements in accordancewith the present invention, which are collectively denoted by referencenumerals 408 and 410. As shown, these configuration specificationstatements are written in a special comment form beginning with “--##”in order to permit a compiler to easily distinguish the configurationspecification statements from the conventional HDL code and HDLcomments. Configuration specification statements preferably employ asyntax that is insensitive to case and white space.

[0090] With reference now to FIG. 4B, there is illustrated an exemplaryHDL file 400′ that includes a reference to an external configurationfile containing one or more configuration specification statements inaccordance with the present invention. As indicated by prime notation(′), HDL file 400′ is identical to HDL file 400 in all respects exceptthat configuration specification statements 408,410 are replaced withone or more (and in this case only one) configuration file referencestatement 412 referencing a separate configuration file 414 containingconfiguration specification statements 408, 410.

[0091] Configuration file reference statement 412, like the embeddedconfiguration specification statements illustrated in FIG. 4A, isidentified as a configuration statement by the identifier “--##”.Configuration file reference statement 412 includes the directive“cfg_file”, which instructs the compiler to locate a separateconfiguration file 414, and the filename of the configuration file(i.e., “file00”). Configuration files, such as configuration file 412,preferably all employ a selected filename extension (e.g., “.cfg”) sothat they can be easily located, organized, and managed within the filesystem employed by data processing system 6.

[0092] As discussed further below with reference to FIG. 8,configuration specification statements, whether embedded within an HDLfile or collected in one or more configuration files 414, are processedby a compiler together with the associated HDL files.

[0093] In accordance with a preferred embodiment of the presentinvention, configuration specification statements, such as configurationspecification statements 408, 410, facilitate configuration ofconfiguration latches within a digital design by instantiating one ormore instances of a configuration entity referred to herein genericallyas a “Dial.” A Dial's function is to map between an input value and oneor more output values. In general, such output values ultimatelydirectly or indirectly specify configuration values of configurationlatches. Each Dial is associated with a particular design entity in thedigital design, which by convention is the design entity specified bythe HDL source file containing the configuration specification statementor configuration file reference statement that causes the Dial to beinstantiated. Consequently, by virtue of their association withparticular design entities, which all have unique instantiationidentifiers, Dials within a digital design can be uniquely identified aslong as unique Dial names are employed within any given design entity.As will become apparent, many different types of Dials can be defined,beginning with a Latch Dial (or “LDial”).

[0094] Referring now to FIG. 5A, there is depicted a representation ofan exemplary LDial 500. In this particular example, LDial 500, which hasthe name “bus ratio”, is utilized to specify values for configurationlatches in a digital design in accordance with an enumerated input valuerepresenting a selected ratio between a component clock frequency andbus clock frequency.

[0095] As illustrated, LDial 500, like all Dials, logically has a singleinput 502, one or more outputs 504, and a mapping table 503 that mapseach input value to a respective associated output value for each output504. That is, mapping table 503 specifies a one-to-one mapping betweeneach of one or more unique input values and a respective associatedunique output value. Because the function of an LDial is to specify thelegal values of configuration latches, each output 504 of LDial 500logically controls the value loaded into a respective configurationlatch 505. To prevent conflicting configurations, each configurationlatch 505 is directly specified by one and only one Dial of any typethat is capable of setting the configuration latch 505.

[0096] At input 502, LDial 500 receives an enumerated input value (i.e.,a string) among a set of legal values including “2:1”, “3:1” and “4:1”.The enumerated input value can be provided directly by software (e.g.,by a software simulator or service processor firmware) or can beprovided by the output of another Dial, as discussed further below withrespect to FIG. 7A. For each enumerated input value, the mapping table503 of LDial 500 indicates a selected binary value (i.e., “0” or “1”)for each configuration latch 505.

[0097] With reference now to FIG. 5B, there is illustrated adiagrammatic representation of a simulation model logically includingDials. Simulation model 300′ of FIG. 5B, which as indicated by primenotation includes the same design entities arranged in the samehierarchical relation as simulation model 300 of FIG. 3, illustrates twoproperties of Dials, namely, replication and scope.

[0098] Replication is a process by which a Dial that is specified in orreferenced by an HDL file of a design entity is automaticallyinstantiated each time that the associated design entity isinstantiated. Replication advantageously reduces the amount of dataentry a designer is required to perform to create multiple identicalinstances of a Dial. For example, in order to instantiate the sixinstances of LDials illustrated in FIG. 5B, the designer need only codetwo LDial configuration specification statements utilizing either of thetwo techniques illustrated in FIGS. 4A and 4B. That is, the designercodes a first LDial configuration specification statement (orconfiguration file reference statement pointing to an associatedconfiguration file) into the HDL file of design entity A 306 in order toautomatically instantiate LDials 506 a 0, 506 a 1, 506 b 0 and 506 b 1within entity A instantiations 306 a 0, 306 a 1, 306 b 0 and 306 b 1,respectively. The designer codes a second LDial configurationspecification statement (or configuration file reference statementpointing to an associated configuration file) into the HDL file ofdesign entity FXU 304 in order to automatically instantiate LDials 510 aand 510 b within FXU entity instantiations 304 a and 304 b,respectively. The multiple instances of the LDials are then createdautomatically as the associated design entities are replicated by thecompiler. Replication of Dials within a digital design can thussignificantly reduce the input burden on the designer as compared toprior art methodologies in which the designer had to individuallyenumerate in the configuration software each configuration latch valueby hand. It should be noted that the property of replication does notnecessarily require all instances of a Dial to generate the same outputvalues; different instances of the same Dial can be set to generatedifferent outputs by providing them different inputs.

[0099] The “scope” of a Dial is defined herein as the set of entities towhich the Dial can refer in its specification. By convention, the scopeof a Dial comprises the design entity with which the Dial is associated(i.e., the design entity specified by the HDL source file containing theconfiguration specification statement or configuration file referencestatement that causes the Dial to be instantiated) and any design entitycontained within the associated design entity (i.e., the associateddesign entity and its descendents). Thus, a Dial is not constrained tooperate at the level of the design hierarchy at which it isinstantiated, but can also specify configuration latches at any lowerlevel of the design hierarchy within its scope. For example, LDials 510a and 510 b, even though associated with FXU entity instantiations 304 aand 304 b, respectively, can specify configuration latches within entityC instantiations 312 a and 312 b, respectively.

[0100]FIG. 5B illustrates another important property of LDials (andother Dials that directly specify configuration latches). In particular,as shown diagrammatically in FIG. 5B, designers, who are accustomed tospecifying signals in HDL files, are permitted in a configurationspecification statement to specify signal states set by a Dial ratherthan values to be loaded into an “upstream” configuration latch thatdetermines the signal state. Thus, in specifying LDial 506, the designercan specify possible signal states for a signal 514 set by aconfiguration latch 512. Similarly, in specifying LDial 510, thedesigner can specify possible signal states for signal 522 set byconfiguration latch 520. The ability to specify signal states ratherthan latch values not only coincides with designers' customary manner ofthinking about a digital design, but also reduces possible errorsintroduced by the presence of inverters between the configuration latch512, 520 and the signal of interest 514, 522, as discussed furtherbelow.

[0101] Referring now to FIG. 5C, there is depicted another diagrammaticrepresentation of a simulation model including an LDial. As indicated byprime notation, simulation model 300″ of FIG. 5C includes the samedesign entities arranged in the same hierarchical relation as simulationmodel 300 of FIG. 3.

[0102] As shown, simulation model 300″ of FIG. 5C includes an LDial 524associated with top-level design entity 302. LDial 524 specifies thesignal states of each signal sig1 514, which is determined by arespective configuration latch 512, the signal states of each signalsig2 522, which is determined by a respective configuration latch 520,the signal state of signal sig4 532, which is determined byconfiguration latch 530, and the signal state of signal sig3 536, whichis determined by configuration latch 534. Thus, LDial 524 configures thesignal states of numerous different signals, which are all instantiatedat or below the hierarchy level of LDial 524 (which is the top level).

[0103] As discussed above with respect to FIGS. 4A and 4B, LDial 524 isinstantiated within top-level entity 302 of simulation model 300″ byembedding within the HDL file of top-level entity 302 a configurationspecification statement specifying LDial 524 or a configuration filereference statement referencing a separate configuration file containinga configuration specification statement specifying LDial 524. In eithercase, an exemplary configuration specification statement for LDial 524is as follows: LDial bus ratio (FXU0.A0.SIG1, FXU0.A1.SIG1,FXU0.B.C.SIG2(0..5), FXU1.A0.SIG1, FXU1.A1.SIG1, FXU1.B.C.SIG2(0..5),FPU0.SIG3, SIG4(0..3) ) = {2:1 =>0b0, 0b0, 0x00,   0b0, 0b0, 0x00,  0b0, 0x0; 3:1 => 0b1, 0b1, 0x01,   0b1, 0b1, 0x01,   0b0, 0x1; 4:1 =>0b1, 0b1, 0x3F,   0b1, 0b1, 0x3F,   0b1, 0xF };

[0104] The exemplary configuration specification statement given abovebegins with the keyword “LDial,” which specifies that the type of Dialbeing declared is an LDial, and the Dial name, which in this case is“bus ratio.” Next, the configuration specification statement enumeratesthe signal names whose states are controlled by the LDial. As indicatedabove, the signal identifier for each signal is specified hierarchically(e.g., FXU0.A0.SIG1 for signal 514 a 0) relative to the default scope ofthe associated design entity so that different signal instances havingthe same signal name are distinguishable. Following the enumeration ofthe signal identifiers, the configuration specification statementincludes a mapping table listing the permitted enumerated input valuesof the LDial and the corresponding signal values for each enumeratedinput value. The signal values are associated with the signal namesimplicitly by the order in which the signal names are declared. Itshould again be noted that the signal states specified for allenumerated values are unique, and collectively represent the only legalpatterns for the signal states.

[0105] Several different syntaxes can be employed to specify the signalstates. In the example given above, signal states are specified ineither binary format, which specifies a binary constant preceded by theprefix “0b”, or in hexadecimal format, which specifies a hexadecimalconstant preceded by the prefix “0x”. Although not shown, signal statescan also be specified in integer format, in which case no prefix isemployed. For ease of data entry, the configuration specificationlanguage of ECAD system 35 also preferably supports a concatenatedsyntax in which one constant value, which is automatically extended withleading zeros, is utilized to represent the concatenation of all of thedesired signal values. In this concatenated syntax, the mapping table ofthe configuration specification statement given above can be rewrittenas: {2:1 => 0,  3:1 => 0x183821,  4:1 => 0x1FFFFF };

[0106] in order to associate enumerated input value 2:1 with aconcatenated bit pattern of all zeros, to associate the enumerated inputvalue 3:1 with the concatenated bit pattern ‘0b110000011100000100001’,and to associate the enumerated input value 4:1 with a concatenated bitpattern of all ones.

[0107] With reference now to FIG. 5D, there is illustrated adiagrammatic representation of a special case of an LDial having aone-bit output, which is defined herein as a Switch. As shown, a Switch540 has a single input 502, a single 1-bit output 504 that controls thesetting of a configuration latch 505, and a mapping table 503 that mapseach enumerated input value that may be received at input 502 to a 1-bitoutput value driven on output 504.

[0108] Because Switches frequently comprise a significant majority ofthe Dials employed in a digital design, it is preferable if theenumerated value sets for all Switches in a simulation model of adigital design are the same (e.g., “ON”/“OFF”). In a typical embodimentof a Switch, the “positive” enumerated input value (e.g., “ON”) ismapped by mapping table 503 to an output value of 0b1and the “negative”enumerated input value (e.g., “OFF”) is mapped to an output value of0b0. In order to facilitate use of logic of the opposite polarity, aNegative Switch or NSwitch declaration is also preferably supported thatreverses this default correspondence between input values and outputvalues in mapping table 503.

[0109] The central advantage to defining a Switch primitive is areduction in the amount of input that designers are required to enter.In particular, to specify a comparable 1-bit LDial, a designer would berequired to enter a configuration specification statement of the form:LDial mode (signal) = {ON =>b1;  OFF =>b0 };

[0110] A Switch performing the same function, on the other hand, can bespecified with the configuration specification statement:

[0111] Switch mode (signal);

[0112] Although the amount of data entry eliminated by the use ofSwitches is not particularly significant when only a single Switch isconsidered, the aggregate reduction in data entry is significant whenthe thousands of switches in a complex digital design are taken intoconsideration.

[0113] Referring now to FIG. 6A, there is depicted a diagrammaticrepresentation of an Integer Dial (“IDial”) in accordance with apreferred embodiment of the present invention. Like an LDial, an IDialdirectly specifies the value loaded into each of one or moreconfiguration latches 605 by indicating within mapping table 603 acorrespondence between each input value received at an input 602 and anoutput value for each output 604. However, unlike LDials, which can onlyreceive as legal input values the enumerated input values explicitly setforth in their mapping tables 503, the legal input value set of an IDialincludes all possible integer values within the bit size of output 604.(Input integer values containing fewer bits than the bit size ofoutput(s) 604 are right justified and extended with zeros to fill allavailable bits.) Because it would be inconvenient and tedious toenumerate all of the possible integer input values in mapping table 603,mapping table 603 simply indicates the manner in which the integer inputvalue received at input 602 is applied to the one or more outputs 604.

[0114] IDials are ideally suited for applications in which one or moremulti-bit registers must be initialized and the number of legal valuesincludes most values of the register(s). For example, if a 4-bitconfiguration register comprising 4 configuration latches and an 11-bitconfiguration register comprising 11 configuration latches were both tobe configured utilizing an LDial, the designer would have to explicitlyenumerate up to 2¹⁵ input values and the corresponding output bitpatterns in the mapping table of the LDial. This case can be handledmuch more simply with an IDial utilizing the following configurationspecification statement:

IDial cnt_value (sig1 (0 . . . 3), sig2 (0 . . . 10));

[0115] In the above configuration specification statement, “IDial”declares the configuration entity as an IDial, “cnt value” is the nameof the IDial, “sig1” is a 4-bit signal output by the 4-bit configurationregister and “sig2” is an 11-bit signal coupled to the 11-bitconfiguration register. In addition, the ordering and number of bitsassociated with each of sig1 and sig2 indicate that the 4 high-orderbits of the integer input value will be utilized to configure the 4-bitconfiguration register associated with sig1 and the 11 lower-order bitswill be utilized to configure the 11-bit configuration registerassociated with sig2. Importantly, although mapping table 603 indicateswhich bits of the integer input values are routed to which outputs, noexplicit correspondence between input values and output values isspecified in mapping table 603.

[0116] IDials may also be utilized to specify the same value formultiple replicated configuration registers, as depicted in FIG. 6B. Inthe illustrated embodiment, an IDial 610, which can be described as anIDial “splitter”, specifies the configuration of three sets ofreplicated configuration registers each comprising 15 configurationlatches 605 based upon a single 15-bit integer input value. An exemplaryconfiguration specification statement for instantiating IDial 610 may begiven as follows: IDial cnt_value(A0.sig1(0..7), A0.sig2(8..14);  A1.sig1(0..7), A1.sig2(8..14);   A3.sig1(0..7), A3.sig2(8..14)  );

[0117] In the above configuration specification statement, “IDial”declares the configuration entity as an IDial, and “cnt_value” is thename of the IDial. Following the IDial name are three scope fieldsseparated by semicolons (“;”). Each scope field indicates how the bitsof the input integer value are applied to particular signals. Forexample, the first scope field specifies that the 8 high-order bits ofthe integer input value will be utilized to configure the 8-bitconfiguration register associated with the signal A0.sig1 and the 7lower-order bits will be utilized to configure the 7-bit configurationregister associated with A0.sig2. The second and third scope fieldsspecify that the corresponding configuration registers within designentities A1 and A3 will be similarly configured. Importantly, theinteger input bits can be allocated differently in each scope field aslong as the total number of bits specified in each scope field is thesame.

[0118] Although the configuration of a digital design can be fullyspecified utilizing LDials alone or utilizing LDials and IDials, in manycases it would be inefficient and inconvenient to do so. In particular,for hierarchical digital designs such as that illustrated in FIG. 5C,the use of LDials and/or IDials alone would force many Dials to higherlevels of the design hierarchy, which, from an organizationalstandpoint, may be the responsibility of a different designer or designgroup than is responsible for the design entities containing theconfiguration latches controlled by the Dials. As a result, properconfiguration of the configuration latches would require not onlysignificant organizational coordination between design groups, but alsothat designers responsible for higher levels of the digital design learnand include within their HDL files details regarding the configurationof lower level design entities. Moreover, implementing Dials at higherlevels of the hierarchy means that lower levels of the hierarchy cannotbe independently simulated since the Dials controlling the configurationof the lower level design entities are not contained within the lowerlevel design entities themselves.

[0119] In view of the foregoing, the present invention recognizes theutility of providing a configuration entity that supports thehierarchical combination of Dials to permit configuration of lowerlevels of the design hierarchy by lower-level Dials and control of thelower-level Dials by one or more higher-level Dials. The configurationspecification language of the present invention terms a higher-levelDial that controls one or more lower-level Dials as a Control Dial(“CDial”).

[0120] Referring now to FIG. 7A, there is depicted a diagrammaticrepresentation of a CDial 700 a in accordance with the presentinvention. CDial 700 a, like all Dials, preferably has a single input702, one or more outputs 704, and a mapping table 703 that maps eachinput value to a respective associated output value for each output 704.Unlike LDials and IDials, which directly specify configuration latches,a CDial 700 does not directly specify configuration latches. Instead, aCDial 700 controls one or more other Dials (i.e., CDials and/or LDialsand/or IDials) logically coupled to CDial 700 in an n-way “Dial tree” inwhich each lower-level Dial forms at least a portion of a “branch” thatultimately terminates in “leaves” of configuration latches. Dial treesare preferably constructed so that no Dial is instantiated twice in anyDial tree.

[0121] In the exemplary embodiment given in FIG. 7A, CDial 700 areceives at input 702 an enumerated input value (i.e., a string) among aset of legal values including “A”, . . . “N”. If CDial 700 a (or anLDial or IDial) is a top-level Dial (i.e., there are no Dials “above” itin a Dial tree), CDial 700 a receives the enumerated input valuedirectly from software (e.g., simulation software or firmware).Alternatively, if CDial 700 a forms part of a “branch” of a dial tree,then CDial 700 a receives the enumerated input value from the output ofanother CDial. For each legal enumerated input value that can bereceived at input 702, CDial 700 a specifies a selected enumerated valueor bit value for each connected Dial (e.g., Dials 700 b, 500 and 600) inmapping table 703. The values in mapping table 703 associated with eachoutput 704 are interpreted by ECAD system 35 in accordance with the typeof lower-level Dial coupled to the output 704. That is, values specifiedfor LDials and CDials are interpreted as enumerated values, while valuesspecified for IDials are interpreted as integer values. With thesevalues, each of Dials 700 b, 500 and 600 ultimately specifies, eitherdirectly or indirectly, the values for one or more configuration latches705.

[0122] With reference now to FIG. 7B, there is illustrated anotherdiagrammatic representation of a simulation model containing a Dial treeincluding a top-level CDial that controls multiple lower-level LDials.As indicated by prime notation, simulation model 300′″ of FIG. 7Bincludes the same design entities arranged in the same hierarchicalrelation as simulation model 300 of FIG. 3 and contains the sameconfiguration latches and associated signals as simulation model 300′″of FIG. 5C.

[0123] As shown, simulation model 300′″ of FIG. 7B includes a top-levelCDial 710 associated with top-level design entity 302. Simulation model300′″ further includes four LDials 712 a, 712 b, 714 and 716. LDial 712a, which is associated with entity instantiation A0 304 a, controls thesignal states of each signal sig1 514 a, which is determined by arespective configuration latch 512 a, and the signal state of signalsig2 522 a, which is determined by configuration latch 520 a. LDial 712b, which is a replication of LDial 712 a associated with entityinstantiation A1 304 b, similarly controls the signal states of eachsignal sig1 514 b, which is determined by a respective configurationlatch 512 b, and the signal state of signal sig2 522 b, which isdetermined by configuration latch 520 b. LDial 714, which is associatedwith top-level entity 302, controls the signal state of signal sig4 532,which is determined by configuration latch 530. Finally, LDial 716,which is associated with entity instantiation FPU0 314, controls thesignal state of signal sig3 536, which is determined by configurationlatch 534. Each of these four LDials is controlled by CDial 710associated with top-level entity 302.

[0124] As discussed above with respect to FIGS. 4A and 4B, CDial 710 andeach of the four LDials depicted in FIG. 7B is instantiated within theassociated design entity by embedding a configuration specificationstatement (or a configuration file reference statement pointing to aconfiguration file containing a configuration specification statement)within the HDL file of the associated design entity. An exemplaryconfiguration specification statement utilized to instantiate each Dialshown in FIG. 7B is given below: CDial BusRatio (FXU0.BUSRATIO,FXU1.BUSRATIO, FPU0.BUSRATIO, BUSRATIO)= {2:1 => 2:1, 2:1, 2:1, 2:1; 3:1 => 3:1, 3:1, 3:1, 3:1; 4:1 => 4:1, 4:1, 4:1, 4:1 }; LDial BusRatio(A0.sig1, A1.sig1, B.C.sig2(0..5)) = {2:1 => 0b0, 0b0, 0x00;  3:1 =>0b1, 0b1, 0x01; 4:1 => 0b1, 0b1, 0x3F; }; LDial BusRatio (sig3) = {2:1=> 0b0;  3:1 => 0b0;  4:1 => 0b1 }; LDial BusRatio (sig4(0..3)) = {2:1=> 0x0;  3:1 => 0x1;  4:1 => 0xF };

[0125] By implementing a hierarchical Dial tree in this manner, severaladvantages are realized. First, the amount of software code that must beentered is reduced since the automatic replication of LDials 712 withinFXU entity instantiations 304 a and 304 b allows the code specifyingLDials 712 to be entered only once. Second, the organizationalboundaries of the design process are respected by allowing each designer(or design team) to specify the configuration of signals within thedesign entity for which he is responsible. Third, coding of upper levelDials (i.e., CDial 710) is greatly simplified, reducing the likelihoodof errors. Thus, for example, the CDial and LDial collection specifiedimmediately above performs the same function as the “large” LDialspecified above with reference to FIG. 5C, but with much less complexityin any one Dial.

[0126] Many Dials, for example, Switches utilized to disable aparticular design entity in the event an uncorrectable error isdetected, have a particular input value that the Dial should have innearly all circumstances. For such Dials, the configurationspecification language of the present invention permits a designer toexplicitly specify in a configuration specification statement a defaultinput value for the Dial. In an exemplary embodiment, a Default value isspecified by including “=default value” following the specification of aDial and prior to the concluding semicolon. For example, a default valuefor a CDial, can be given as follows: CDial BusRatio (FXU0.BUSRATIO,FXU1.BUSRATIO, FPU0.BUSRATIO, BUSRATIO)= {2:1 => 2:1, 2:1, 2:1, 2:1; 3:1 => 3:1, 3:1, 3:1, 3:1; 4:1 => 4:1, 4:1, 4:1, 4:1 } = 2:1;

[0127] It should be noted that for CDials and LDials, the specifieddefault value is required to be one of the legal enumerated values,which are generally (i.e., except for Switches) listed in the mappingtable. For Switches, the default value must be one of the predefinedenumerated values of “ON” and “OFF”.

[0128] A default value for an IDial can similarly be specified asfollows: IDial cnt_value(A0.sig1(0..7), A0.sig2(8..14);   A1.sig1(0..7),A1.sig2(8..14);   A3.sig1(0..7), A3.sig2(8..14)  ) = 0x7FFF;

[0129] In this case, a constant, which can be given in hexadecimal,decimal or binary format, provides the default output value of eachsignal controlled by the IDial. In order to apply the specified constantto the indicated signal(s), high order bits are truncated or padded withzeros, as needed.

[0130] The use of default values for Dials is subject to a number ofrules. First, a default value may be specified for any type of Dialincluding LDials, IDials (including those with split outputs) andCDials. Second, if default values are specified for multiple Dials in amultiple-level Dial tree, only the highest-level default value affectingeach “branch” of the Dial tree is applied (including that specified forthe top-level Dial), and the remaining default values, if any, areignored. Despite this rule, it is nevertheless beneficial to specifydefault values for lower-level Dials in a Dial tree because the defaultvalues may be applied in the event a smaller portion of a model isindependently simulated, as discussed above. In the event that thecombination of default values specified for lower-level Dials formingthe “branches” of a Dial tree do not correspond to a legal output valueset for a higher-level Dial, the compiler will flag an error. Third, adefault value is overridden when a Dial receives an input to activelyset the Dial.

[0131] By specifying default values for Dials, a designer greatlysimplifies use of Dials by downstream organizational groups by reducingthe number of Dials that must be explicitly set for simulation orhardware configuration. In addition, as discussed further below, use ofdefault values assists in auditing which Dials have been actively set.

[0132] In addition to defining syntax for configuration specificationstatements specifying Dials, the configuration specification language ofthe present invention supports at least two additional HDL semanticconstructs: comments and attribute specification statements. A comment,which may have the form:

BusRatio.comment=“The bus ratio Dial configures the circuit inaccordance with a selected processor/interconnect frequency ratio”;

[0133] permits designers to associate arbitrary strings delimited byquotation marks with particular Dial names. As discussed below withreference to FIG. 8, these comments are processed during compilation andincluded within a configuration documentation file in order to explainthe functions, relationships, and appropriate settings of the Dials.

[0134] Attribute specification statements are statements that declare anattribute name and attribute value and associate the attribute name witha particular Dial name. For example, an attribute specificationstatement may have the form:

BusRatio.attribute (myattribute)=scom57(0:9);

[0135] In this example, “BusRatio.attribute” declares that thisstatement is an attribute specification statement associating anattribute with a Dial having “BusRatio” as its Dial name, “myattribute”is the name of the attribute, and “scom57(0:9)” is a string thatspecifies the attribute value. Attributes support custom features andlanguage extensions to the base configuration specification language.

[0136] Referring now to FIG. 8, there is depicted a high level flowdiagram of a model build process in which HDL files containingconfiguration statements are compiled to obtain a simulation executablemodel and a simulation configuration database for a digital design. Theprocess begins with one or more design entity HDL source code files 800,which include configuration specification statements and/orconfiguration file reference statements, and, optionally, one or moreconfiguration specification reference files 802. HDL compiler 804processes HDL file(s) 800 and configuration specification file(s) 802,if any, beginning with the top level entity of a simulation model andproceeding in a recursive fashion through all HDL file(s) 800 describinga complete simulation model. As HDL compiler 804 processes each HDL file800, HDL compiler 804 creates “markers” in the design intermediate files806 produced in memory to identify configuration statements embedded inthe HDL code and any configuration specification files referenced by anembedded configuration file reference statement.

[0137] Thereafter, the design intermediate files 806 in memory areprocessed by a configuration compiler 808 and model build tool 810 tocomplete the model build process. Model build tool 810 processes designintermediate files 806 into a simulation executable model 816, that whenexecuted, models the logical functions of the digital design, which mayrepresent, for example, a portion of an integrated circuit, an entireintegrated circuit or module, or a digital system including multipleintegrated circuits or modules. Configuration compiler 808 processes theconfiguration specification statements marked in design intermediatefiles 806 and creates from those statements a configurationdocumentation file 812 and a configuration database 814.

[0138] Configuration documentation file 812 lists, in human-readableformat, information describing the Dials associated with the simulationmodel. The information includes the Dials' names, their mapping tables,the structure of Dial trees, if any, instance information, etc. Inaddition, as noted above, configuration documentation file 812 includesstrings contained in comment statements describing the functions andsettings of the Dials in the digital design. In this manner,configuration documentation suitable for use with both a simulationmodel and a hardware implementation of a digital design is aggregated ina “bottom-up” fashion from the designers responsible for creating theDials. The configuration documentation is then made available to alldownstream organizational groups involved in the design, simulation,laboratory hardware evaluation, and commercial hardware implementationof the digital design.

[0139] Configuration database 814 contains a number of data structurespertaining to Dials. As described in detail below, these data structuresinclude Dial data structures describing Dial entities, latch datastructures, and Dial instance data structures. These data structuresassociate particular Dial inputs with particular configuration valuesused to configure the digital design (i.e., simulation executable model816). In a preferred embodiment, the configuration values can bespecified in terms of either signal states or configuration latchvalues, and the selection of which values are used is user-selectable.Configuration database 814 is accessed via Application ProgrammingInterface (API) routines during simulation of the digital designutilizing simulation executable model 816 and is further utilized togenerate similar configuration databases for configuring physicalrealizations of the digital design. In a preferred embodiment, the APIsare designed so that only top-level Dials (i.e., LDials, IDials orCDials without a CDial logically “above” them) can be set and all Dialvalues can be read.

[0140] As described above, the configuration specification language ofthe present invention advantageously permits the specification of theoutput values of LDials and IDials by reference to signal names (e.g.,“sig1 ”). As noted above, a key motivation for this feature is thatdesigners tend to think in terms of configuring operative signals toparticular signal states, rather than configuring the associatedconfiguration latches. In practice, however, a signal that a designerdesires to configure to a particular state may not be directly connectedto the output of an associated configuration latch. Instead, a signal tobe configured may be coupled to an associated configuration latchthrough one or more intermediate circuit elements, such as buffers andinverters. Rather than burdening the designer with manually tracing backeach configurable signal to an associated configuration latch and thendetermining an appropriate value for the configuration latch,configuration compiler 808 automatically traces back a specified signalto the first storage element (i.e., configuration latch) coupled to thesignal and performs any necessary inversions of the designer-specifiedsignal state value to obtain the proper value to load into theconfiguration latch.

[0141] With reference now to FIG. 9A, there is illustrated a portion ofa digital design including an LDial 900 that controls the states of aplurality of signals 904 a-904 e within the digital design. Whenconfiguration compiler 808 performs a traceback of signal 904 a, noinversion of the designer-specified signal states is required becausesignal 904 a is directly connected to configuration latch 902 a.Accordingly, configuration compiler 808 stores into configurationdatabase 814 the designer-specified values from the configurationspecification statement of LDial 900 as the values to be loaded intoconfiguration latch 902 a. Traceback of signal 904 b to configurationlatch 902 b similarly does not result in the inversion of anydesigner-specified values from the configuration specification statementof LDial 900 because the only intervening element between signal 904 band configuration register 902 b is a non-inverting buffer 906.

[0142] Configuration latches, such as configuration latches 902 c and902 d, are frequently instantiated by designers through inclusion in anHDL file 800 of an HDL statement referencing a latch primitive in an HDLdesign library. The latch entity 903 a, 903 b inserted into thesimulation executable model in response to such HDL library referencesmay include inverters, such as inverters 908, 910, which are notexplicitly “visible” to the designer in the HDL code. The automatictraceback performed by configuration compiler 808 nevertheless detectsthese inverters, thus preventing possible configuration errors.

[0143] Accordingly, when performing a traceback of signal 904 c,configuration compiler 808 automatically inverts the designer-specifiedconfiguration value specified for signal 904 c before storing theconfiguration value for configuration latch 902 c in configurationdatabase 814 because of the presence of an inverter 908 between signal904 c and configuration latch 902 e. When configuration compiler 808performs traceback of signal 904 d, however, configuration compiler 808does not invert the designer-specified signal state values despite thepresence of inverters 910, 914 and buffer 912 in the signal path becausethe logic is collectively non-inverting. It should be noted thatconfiguration compiler 808 can accurately process both “hidden”inverters like inverter 910 and explicitly declared inverters likeinverter 914.

[0144]FIG. 9A finally illustrates a signal 904 e that is coupled tomultiple configuration latches 902 e and 902 f through an intermediateAND gate 916. In cases like this in which the traceback process detectsfanout logic between the specified signal and the closest configurationlatch, it is possible to configure configuration compiler 808 togenerate appropriate configuration values for configuration latches 902e, 902 f based upon the designer-specified signal state values forsignal 904e. However, it is preferable if configuration compiler 808flags the configuration specification statement for LDial 900 ascontaining an error because the compiler-selected values forconfiguration latches 902 e, 902 f may affect other circuitry thatreceives the configuration values from configuration latches 902 inunanticipated ways.

[0145] Referring now to FIG. 9B, there is depicted a high level logicalflowchart of the traceback process implemented by configuration compiler808 for each signal name specified in a configuration specificationstatement. As shown, the process begins at block 920 and then proceedsto block 922-924, which illustrate configuration compiler 808initializing an inversion count to zero and then locating the signalidentified by the signal name specified in a configuration specificationstatement.

[0146] The process then enters a loop comprising blocks 926-936, whichcollectively represent configuration compiler 808 tracing back thespecified signal to the first latch element in the signal path.Specifically, as illustrated at blocks 926-930, configuration compiler808 determines whether the next “upstream” circuit element in the signalpath is a latch (926), buffer (928) or inverter (930). If the circuitelement is a latch, the process exits the loop and passes to block 940,which is described below. If, however, the circuit element is a buffer,the process passes to block 934, which illustrates configurationcompiler moving to the next upstream circuit element to be processedwithout incrementing the inversion count. If the circuit element is aninverter, the process passes to blocks 936 and 934, which depictsincrementing the inversion count and then moving to the next upstreamcircuit element to be processed. In this manner, configuration compilertraces back a specified signal to a configuration latch whiledetermining a number of inversions of signal state implemented by thecircuit elements in the path. As noted above, if configuration compiler808 detects a circuit element other than a buffer or inverter in thesignal path, configuration compiler 808 preferably flags an error, asshown at block 946. The process thereafter terminates at block 950.

[0147] Following detection of a configuration latch at block 926,configuration compiler 808 determines whether the inversion count is oddor even. As shown at blocks 940-944, if the inversion count is odd,configuration compiler inverts the designer-specified configurationvalues for the signal at block 942 prior to inserting the values intoconfiguration database 814. No inversion is performed prior to insertingthe configuration values into configuration database 814 if theinversion count is even. The process thereafter terminates at block 950.

[0148] As has been described, the present invention provides aconfiguration specification language that permits a designer of adigital system to specify a configuration for the digital systemutilizing configuration statements embedded in the HDL design filesdescribing the digital system. The configuration statements logicallyinstantiate within the digital design one or more Dials, which provideconfiguration values for the digital design in response to particularinputs. The Dials, like the design entities comprising the digitaldesign, may be hierarchically arranged. The configuration specificationstatements are compiled together with the HDL files describing thedigital design to produce a configuration database that may be accessedto configure a simulation executable model or (after appropriatetransformations) a physical realization of the digital design. Thecompilation of the configuration specification statements preferablysupports a traceback process in which designer-specified configurationvalues for a signal are inverted in response to detection of an oddnumber of inverters coupled between the signal and an associatedconfiguration latch.

[0149] With reference again to FIG. 5C, recall that an exemplaryconfiguration specification statement for LDial 524 includes aparenthetical signal enumeration of the form: LDial bus ratio(FXU0.A0.SIG1, FXU0.A1.SIG1, FXU0.B.C.SIG2(0..5), FXU1.A0.SIG1,FXU1.A1.SIG1, FXU1.B.C.SIG2(0..5), FPU0.SIG3, SIG4(0..3) ) = ...

[0150] It should be noted that the signal enumeration section of theconfiguration specification statement individually, hierarchically andexplicitly enumerates the signal identifier of each signal instanceconfigured by the Dial, beginning from the scope of the design entitywith which the Dial is associated (which by convention is the designentity in whose HDL file the configuration specification statement orconfiguration reference statement instantiating the Dial is embedded).This syntax is referred to herein as a “full expression” of a signalidentifier. Employing “full expression” syntax in the signal enumerationsection of the configuration specification statement for an LDial orIDial or in the Dial enumeration section of the configurationspecification statement of a CDial requires the designer to know andcorrectly enter the hierarchical identifier for each instance of asignal (or lower-level Dial) controlled by the Dial. Consequently, if anew instance of the same signal (or lower-level Dial) were later addedto the digital design, the designer must carefully review theconfiguration specification statement of the Dial(s) referencing otherinstances of the same signal (or Dial) and update the signal (or Dial)enumeration section to include the full expression of the newly addedinstance.

[0151] In order to reduce the amount of input required to input thesignal (or Dial) enumeration sections of configuration specificationstatements and to reduce the burden of code maintenance as new signaland Dial instances are added to the digital design, an ECAD system 35 inaccordance with the present invention also supports a “compactexpression” syntax for the signal (or Dial) enumeration sections ofconfiguration specification statements. This syntax is referred toherein more specifically as “compact signal expression” when applied tothe configuration specification statements of LDials and IDials and isreferred to as “compact Dial expression” when referring to theconfiguration specification statements of CDials.

[0152] In a compact expression of a signal or Dial enumeration, allinstances of an entity within a selected scope for which a commonconfiguration is desired can be enumerated with a single identifier. Forexample, in FIG. 5C, if the designer wants a common configuration forall four instantiations of signal sig1 514, the designer could enumerateall four instantiations in the configuration specification statement ofLDial 524 with the single compact signal expression “[A].sig1 ”, wherethe bracketed term is the name of the entity in which the signal ofinterest occurs. In compact expressions, the default scope of theexpression is implied as the scope of the design entity (in this casetop-level entity 302) with which the Dial is associated. The identifier“[A].sig1 ” thus specifies all four instantiations of signal sig1 514within A entity instantiations 304 within the default scope of top-levelentity 302.

[0153] The scope of the identifier in a compact expression can furtherbe narrowed by explicitly enumerating selected levels of the designhierarchy. For example, the compact expression “FXU1.[A].sig1 ” refersonly to signal sig1 instantiations 514 b 0 and 514 b 1 within FXU1entity instantiation 304 b, but does not encompass signal sig1instantiations 514 a 0 and 514 a 1 within FXU0 entity instantiation 304a.

[0154] Of course, when only a single instance of a signal or Dial isinstantiated at higher levels of the design hierarchy, the compactexpression and the full expression will require approximately the sameamount of input (e.g., “FPU0.sig3” versus “[FPU].sig3” to identifysignal sig3 536). However, it should be noted that if another FPU entity314 were later added to simulation model 300″, the compact expression ofthe identification would advantageously apply to any later added FPUentities within the scope of top-level entity 302.

[0155] Utilizing compact expression, the configuration specificationstatement for LDial 524 can now be rewritten more compactly as follows:LDial bus ratio ([A].SIG1, [C].SIG2(0..5), FPU0.SIG3, SIG4(0..3) ) ={2:1 =>0b0, 0x00, 0b0, 0x0;  3:1 =>0b1, 0x01, 0b0, 0x1;  4:1 =>0b1,0x3F, 0b1, 0xF };

[0156] If the concatenation syntax described above is applied to themapping table, the mapping table can be further reduced to: {2:1 =>0; 3:1 =>0x821;  4:1 =>0xFFF };

[0157] In the concatenation syntax, the signal values are specified inthe mapping table with a single respective bit field for each entityidentifier, irrespective of the number of actual entity instances. Forexample, all instances encompassed by “[A].sig1 ” are represented by 1bit of the specified configuration value, all instances encompassed by“[C].sig2 ” are represented by 6 bits of the specified configurationvalue, the single instance identified by “FPU0.sig3” is represented by 1bit of the specified configuration value, and the single instance of“sig4 (0 . . . 3)” is represented by 4 bits of the specifiedconfiguration value. Thus, utilizing concatenation syntax, the 21 bitscollectively specified by LDial 524 can be specified by an equivalent12-bit pattern.

[0158] Compact Dial expressions are constructed and parsed by thecompiler in the same manner as compact signal expressions. For example,the configuration specification statement for CDial 710 of FIG. 7B canbe rewritten utilizing compact Dial expression as follows: CDialBusRatio ([FXU].BUSRATIO, [FPU].BUSRATIO, BUSRATIO)=        {2:1 => 2:1,2:1, 2:1;         3:1 => 3:1, 3:1, 3:1;         4:1 => 4:1, 4:1, 4:1       };

[0159] Again, this configuration specification statement advantageouslypermits CDial 710 to automatically control any additional LDials named“Bus ratio” that are latter added to simulation model 300′″ through theinstantiation of additional FXU entities 304 or FPU entities 314 withoutany code modification.

[0160] Referring now to FIG. 10, there is depicted a high level logicalflowchart of an exemplary method by which configuration compiler 808parses each signal or Dial identification within a configurationspecification statement in accordance with the present invention. Asdescribed above, each signal or Dial identification is constructedhierarchically from one or more fields separated by periods (“.”). Thelast field specifies an instance name of a signal (e.g., “sig1 ”) orDial (e.g., “Bus_Ratio”), and the preceding fields narrow the scope fromthe default scope, which by convention is the scope of the design entitywith which the Dial is associated.

[0161] As shown, the process begins at block 1000 and then proceeds toblock 1002, which illustrates configuration compiler 808 determiningwhether the first or current field of the signal or Dial identificationcontains an entity identifier enclosed in brackets (e.g., “[A]”), thatis, whether the identification is a compact expression. If so, theprocess passes to block 1020, which is described below. If not,configuration compiler 808 determines at block 1004 whether theidentification is a full expression, by determining whether the first orcurrent field of the identification is the last field of theidentification. If so, the signal or Dial identification is a fullexpression, and the process passes to block 1010. If, on the other hand,the current field of the identification is not the last field,configuration compiler 808 narrows a current scope to the design entityinstantiation identified in the current field of the identification, asdepicted at block 1006. For example, if configuration compiler 808 wereprocessing the identification “FPU0.SIG3” within the configurationspecification statement of CDial 710 of FIG. 7B, configuration compiler808 would narrow the scope from the default scope of top entity 302 toFPU entity instantiation 314. If the entity instantiation indicated bythe current field of the identification exists, as shown at block 1008,the process returns to block 1002 after updating the current field to bethe next field, as shown at block 1009. If, however, the entityinstantiation specified by the current field does not exist within thecurrent scope, configuration compiler 8

[0162] error at block 1032 and terminates processing of the signal orDial identification.

[0163] Referring again to block 1004, when configuration compiler 808detects that it has reached the last field of a full expression, theprocess shown in FIG. 10 passes from block 1004 to block 1010. Block1010 illustrates configuration compiler 1010 attempting to locate withinthe current scope the single signal or Dial instance having a namematching that specified in the last field of the signal or Dialidentification. If configuration compiler 808 determines at block 1012that no matching instance is found within the current scope, the processpasses to block 1032, and configuration compiler 808 flags an error.However, if configuration compiler 808 locates the matching signal orDial instance, then configuration compiler 8

[0164] entry in configuration database 814 binding the signal or Dialinstance to the parameters specified in the mapping table of theconfiguration specification statement of the Dial being processed, asshown at block 1014. Thereafter, processing of the signal or Dialidentification terminates at block 1030.

[0165] With reference now to block 1020 and following blocks, theprocessing of a signal or Dial identification employing compactexpression will now be described. Block 1020 depicts configurationcompiler 808 attempting to locate, within each of one or more instancesin the current scope of the entity indicated by the bracketed field,each Dial or signal instance matching that specified in the signal orDial identification. For example, when processing the compact expression“FXU1.[A].sig1” for simulation model 300′″ of FIG. 7B, configurationcompiler 808, upon reaching the field “[A]”, searches FXU1 forinstantiations of entity A 306, and upon finding entity instantiations306 a 0 and 306 a 1, searches within each of these two entityinstantiations to locate signals instantiations sig1 514 a 0 and 514 a1. If configuration compiler 808 determines at block 1022 that nomatching signal or Dial instance is found within the current scope, theprocess passes to block 1032, which depicts configuration compiler 808terminating processing of the signal or Dial identification afterflagging an error. However, if configuration compiler 808 locates one ormore matching signal or Dial instances, then the process passes fromblock 1022 to block 1024. Block 1024 illustrates configuration compiler808 making one or more entries in configuration database 814 bindingeach matching signal or Dial instance to the parameters specified in themapping table of the configuration specification statement of the Dialbeing processed. Thereafter, processing of the signal or Dialidentification terminates at block 1030.

[0166] Utilizing the compact expressions supported by the presentinvention, the amount of code a designer must enter in a configurationspecification statement can be advantageously reduced. The use ofcompact expressions not only reduces input requirements and thelikelihood of input errors, but also simplifies code maintenance throughthe automatic application of specified configuration parameters to laterentered instances of signals and Dials falling within a selected scope.

[0167] As described above, every Dial has a one-to-one mapping betweeneach of its input values and a unique output value of the Dial. In otherwords, each input value has a unique output value different than theoutput value for any other input value. For CDials and LDials, themapping table must explicitly enumerate each legal input value and itsassociated mapping.

[0168] The requirement that the input values must be explicitlyenumerated in the mapping table limits the overall complexity of anygiven LDial or CDial. For example, consider the case of an integratedcircuit (e.g., a memory controller) containing 10 to 20 configurationregisters each having between 5 and 20 legal values. In many cases,these registers have mutual dependencies—the value loaded in oneregister can affect the legal possibilities of one or more of the otherregisters. Ideally, it would be convenient to specify values for all ofthe registers utilizing a Dial tree controlled by a single CDial. Inthis manner, the configuration of all of the 10 to 20 registers could becontrolled as a group.

[0169] Unfortunately, given the assumptions set forth above, the 10 to20 registers collectively may have over 300,000 legal combinations ofvalues. The specification of a CDial in such a case, althoughtheoretically possible, is undesirable and practically infeasible.Moreover, even if a looping construct could be employed to automateconstruction of the configuration specification statement of the CDial,the configuration specification statement, although informing simulationsoftware which input values are legal, would not inform users how to seta CDial of this size.

[0170] In recognition of the foregoing, the configuration specificationlanguage of the present invention provides a “Dial group” construct. ADial group is a collection of Dials among which the designer desires tocreate an association. The runtime APIs utilized to provide Dial inputvalues observe this association by preventing the individual Dialswithin a Dial group from being set individually. In other words, allDials in a Dial group must be set at the same time so that individualDials are not set independently without concern for the interactionsbetween Dials. Because software enforces an observance of the groupingof the Dials forming a Dial group, use of Dial groups also provides amechanism by which a designer can warn the “downstream” user communitythat an unstated set of interdependencies exists between the Dialscomprising the Dial group.

[0171] With reference now to FIG. 11A, there is illustrated adiagrammatic representation of a Dial group 1100 a. A Dial group 1100 ais defined by a group name 1102 (e.g., “GroupG”) and a Dial list 1104listing one or more Dials or other Dial groups. Dial groups do not haveany inputs or outputs. The Dials listed within Dial list 1104, which areall top-level Dials 1110 a-1110 f, may be LDials, CDials and/or IDials.

[0172]FIG. 11A illustrates that a Dial group 1100 a may be implementedas a hierarchical Dial group that refers to one or more other Dialgroups 1100 b-1100 n in its Dial list 1104. These lower-level Dialgroups in turn refer to one or more top-level Dials 1110 g-1110 k and1110 m-1110 r (or other Dial groups) in their respective Dial lists.

[0173] One motivation for implementing Dial groups hierarchically is tocoordinate configuration of groups of Dials spanning organizationalboundaries. For example, consider a digital system in which 30 Dialslogically belong in a Dial group and 10 of the Dials are containedwithin a first design entity that is the responsibility of a firstdesigner and 20 of the Dials are contained within a second design entitythat is the responsibility of a second designer. Without a hierarchicalDial group, a single Dial group explicitly listing all 30 Dials in itsDial list 1104 would have to be specified at a higher level of thedesign hierarchy encompassing both of the first and second designentities. This implementation would be inconvenient in that the designer(or design team) responsible for the higher-level design entity wouldhave to know all of the related Dials in the lower-level design entitiesand specifically identify each of the 30 Dials in the Dial list 1104 ofthe Dial group.

[0174] An alternative hierarchical approach would entail creating afirst Dial group containing the 10 Dials within the first design entity,a second Dial group containing the 20 Dials within the second designentity, and a third higher-level Dial group that refers to the first andsecond Dial groups. Importantly, the Dial list 1104 of the higher-levelDial group must only refer to the two lower-level Dial groups, thusshielding designers responsible for higher levels of the designhierarchy from low-level details. In addition, code maintenance isreduced since changing which Dials belong to the two lower-level Dialgroups would not affect the Dial list 1104 of the upper-level Dialgroup.

[0175] Dial groups are subject to a number of rules. First, no Dial orDial group may be listed in the Dial list 1104 of more than one Dialgroup. Second, a Dial group must refer to at least one Dial or otherDial group in its Dial list 1104. Third, in its Dial list 1104, a Dialgroup can only refer to Dials or Dial groups within its scope, which byconvention (and like the concept of scope as applied to Dials) is thatof its associated design entity (i.e., the design entity itself and anylower level design entity within the design entity). Fourth, each Dialreferred to in a Dial list 1104 of a Dial group must be a top-levelDial.

[0176] Referring now to FIG. 11B, there is depicted an exemplarysimulation model 1120 illustrating the use of Dial groups. Exemplarysimulation model 1120 includes a top-level design entity 1122 havinginstantiation identifier “TOP:TOP”. Within top-level design entity 1122,two design entities 1124 and 1126 are instantiated, which have entitynames FBC and L2, respectively. FBC entity instantiation 1124 in turninstantiates a Dial instance 1130 having Dial name “C”, a Z entityinstantiation 1132 containing a Dial instance 1134 having Dial name “B”,and two instantiations of entity X 1136, which are respectively named“X0” and “X1”. Each entity X instantiation 1136 contains two entity Yinstantiations 1138, each further instantiating a Dial instance 1140having Dial name “A”. L2 entity instantiation 1126 contains a Dialinstance 1150 having Dial name “D” and two entity L instantiations 1152,each containing a Dial instance 1154 having Dial name “E”.

[0177] As shown, FBC entity instantiation 1124 has an associated Dialgroup instance 1160 having a group name “F”. As indicated by arrows,Dial group instance 1160 includes each of Dials instances 1130, 1134 and1140 within FBC entity instantiation 1124. L2 entity instantiation 1126similarly has an associated Dial group instance 1162 that includes eachof Dial instances 1150 and 1154 within L2 entity instantiation 1126.Both of these Dial group instances in turn belong to a higher-level Dialgroup instance 1164 having group name “H”, which is associated withtop-level design entity 1122.

[0178] Each Dial group instance is created by including within the HDLfile of the associated design entity an appropriate configurationstatement. For example, exemplary syntax for configuration statementscreating Dial groups “F”, “G” and “H” are respectively given as follows:GDial F(C, [Z].B, [Y].A); GDial G(D, [L].E); GDial H(FBC.F, L2.G);

[0179] In each configuration statement, a Dial group is declared by thekeyword “GDial”, which is followed by string (e.g., “F”) representingthe group name. Within the parenthesis following the group name, theDial list for the Dial group is specified. As indicated in theconfiguration statement for Dial group “H”, the Dial list for ahierarchical Dial group specifies other Dial groups in the same manneras Dials. It should also be noted that the compact dial expressionsyntax discussed above can be employed in specifying Dials or Dialgroups in the Dial list, as indicated in the configuration statementsfor Dial groups “F” and “G”. In addition, default values may be appliedto a Dial group by specifying a default value for each top-level Dialincluded in the Dial group.

[0180] Now that basic types of Dials, syntax for their specification,and the application and Dial groups have been described, a descriptionof an exemplary implementation of configuration database 814 and its usewill be provided. To promote understanding of the manner in whichparticular Dial instantiations (or multiple instantiations of a Dial)can be accessed in configuration database 814, a nomenclature for Dialswithin configuration database 814 will be described.

[0181] The nomenclature employed in a preferred embodiment of thepresent invention first requires a designer to uniquely name each Dialspecified within any given design entity, i.e., the designer cannotdeclare any two Dials within the same design entity with the same Dialname. Observing this requirement prevents name collisions between Dialsinstantiated in the same design entity and promotes the arbitrary re-useof design entities in models of arbitrary size. This constraint is nottoo onerous in that a given design entity is usually created by aspecific designer at a specific point in time, and maintaining uniqueDial names within such a limited circumstance presents only a moderateburden.

[0182] Because it is desirable to be able to individually accessparticular instantiations of a Dial entity that may have multipleinstantiations in a given simulation model (e.g., due to replication),use of a Dial name alone is not guaranteed to uniquely identify aparticular Dial entity instantiation in a simulation model. Accordingly,in a preferred embodiment, the nomenclature for Dials leverages theunique instantiation identifier of the associated design entity requiredby the native HDL to disambiguate multiple instances of the same Dialentity with an “extended Dial identifier” for each Dial within thesimulation model.

[0183] As an aside, it is recognized that some HDLs do not strictlyenforce a requirement for unique entity names. For example, conventionalVHDL entity naming constructs permit two design entities to share thesame entity name, entity name. However, VHDL requires that suchidentically named entities must be encapsulated within different VHDLlibraries from which a valid VHDL model may be constructed. In such acircumstance, the entity_name is equivalent to the VHDL library nameconcatenated by a period (“.”) to the entity name as declared in theentity declaration. Thus, pre-pending a distinct VHDL library name tothe entity name disambiguates entities sharing the same entity name.Most HDLs include a mechanism such as this for uniquely naming eachdesign entity.

[0184] In a preferred embodiment, an extended Dial identifier thatuniquely identifies a particular instantiation of a Dial entity includesthree fields: an instantiation identifier field, a design entity name,and a Dial name. The extended Dial identifier may be expressed as astring in which adjacent fields are separated by a period (“.”) asfollows:

<instantiation identifier>.<design entity name>.<Dial name>

[0185] In the extended Dial identifier, the design entity field containsthe entity name of the design entity in which the Dial is instantiated,and the Dial name field contains the name declared for the Dial in theDial configuration specification statement. As described above, theinstantiation identifier specified in the instantiation identifier fieldis a sequence of instantiation identifiers, proceeding from thetop-level entity of the simulation model to the direct ancestor designentity of the given Dial instance, with adjacent instance identifiersseparated by periods (“.”). Because no design entity can include twoDials of the same name, the instantiation identifier is unique for eachand every instance of a Dial within the model.

[0186] The uniqueness of the names in the design entity name field is aprimary distinguishing factor between Dials. By including the designentity name in the extended Dial identifier, each design entity is, ineffect, given a unique namespace for the Dials associated with thatdesign entity, i.e., Dials within a given design entity cannot have namecollisions with Dials associated with other design entities. It shouldalso be noted that it is possible to uniquely name each Dial by usingthe instantiation identifier field alone. That is, due to the uniquenessof instantiation identifiers, Dial identifiers formed by only theinstantiation identifier field and the Dial name field will benecessarily unique. However, such a naming scheme does not associateDials with a given design entity. In practice, it is desirable toassociate Dials with the design entity in which they occur through theinclusion of the design entity field because all the Dialsinstantiations can then be centrally referenced without the need toascertain the names of all the design entity instantiations containingthe Dial.

[0187] As noted above, use of extended Dial identifiers permits theunique identification of a particular instantiation of a Dial andpermits the re-use of design entities within any arbitrary model withoutrisk of Dial name collisions. For example, referring again to FIG. 11B,Dial A entity instantiations 1140 a 0, 1140 a 1, 1140 b 0 and 1140 b 1can be respectively uniquely identified by the following extended Dialidentifiers: FBC.X0.Y0.Y.A FBC.X0.Y1.Y.A FBC.X1.Y0.Y.A FBC.X1.Y1.Y.A

[0188] With an understanding of a preferred nomenclature of Dials,reference is now made to FIG. 12, which is a diagrammatic representationof an exemplary format for a configuration database 814 created byconfiguration compiler 808. In this exemplary embodiment, configurationdatabase 814 includes at least four different types of data structures:Dial definition data structures (DDDS) 1200, Dial instance datastructures (DIDS) 1202, latch data structures 1204 and top-level pointerarray 1206. Configuration database 814 may optionally include additionaldata structures, such as Dial pointer array 1208, latch pointer array1210, instance pointer array 1226 and other data structures depicted indashed-line illustration, which may alternatively be constructed involatile memory when configuration database 814 is loaded, as describedfurther below. Generating these additional data structures only afterconfiguration database 814 is loaded into volatile memory advantageouslypromotes a more compact configuration database 814.

[0189] A respective Dial definition data structure (DDDS) 1200 iscreated within configuration database 814 for each Dial or Dial group inthe digital system. Preferably, only one DDDS 1200 is created inconfiguration database 814 regardless of the number of instantiations ofthe Dial (or Dial group) in the digital system. As discussed below,information regarding particular instantiations of a Dial described in aDDDS 1200 is specified in separate DIDSs 1202.

[0190] As shown, each DDDS 1200 includes a type field 1220 denotingwhether DDDS 1200 describes a Dial or Dial group, and if a Dial, thetype of Dial. In one embodiment, the value set for type field 1220includes “G” for Dial group, “I” for integer Dial (IDial), “L” for latchDial (LDial), and “C” for control Dial (CDial). DDDS 1200 furtherincludes a name field 1222, which specifies the name of the Dial or Dialgroup described by DDDS 1200. This field preferably contains the designentity name of the Dial (or Dial group), followed by a period (“.”),followed by the name of Dial (or Dial group) given in the configurationspecification statement of the Dial (or Dial group). The contents ofname field 1222 correspond to the design entity name and Dial namefields of the extended dial identifier for the Dial.

[0191] DDDS 1200 also includes a mapping table 1224 that contains themapping from the input of the given Dial to its output(s), if required.For LDials and CDials, mapping table 1224 specifies relationshipsbetween input values and output values much like the configurationspecification statements for these Dials. For Dial groups and IDials nothaving a split output, mapping table 1220 is an empty data structure andis not used. In the case of an IDial with a split output, mapping table1220 specifies the width of the replicated integer field and the numberof copies of that field. This information is utilized to map the integerinput value to the various copies of the integer output fields. If theconfiguration specification statement for the Dial has a defaultspecified, DDDS 1200 indicates the default value in default field 1229;if no default is specified, default field 1229 is NULL or is omitted.

[0192] Finally, DDDS 1200 may include an instance pointer array 1226containing one or more instance pointers 1228 a-1228 n pointing to eachinstance of the Dial or Dial group defined by the DDDS 1200. Instancepointer array 1226 facilitates access to multiple instances of aparticular Dial or Dial group.

[0193] As further illustrated in FIG. 12, configuration database 814contains a DIDS 1202 corresponding to each Dial instantiation or Dialgroup instantiation within a digital design. Each DIDS 1202 contains adefinition field 1230 containing a definition pointer 1231 pointing tothe DDDS 1200 of the Dial for which the DIDS 1202 describes a particularinstance. Definition pointer 1231 permits the Dial name, Dial type andmapping table of an instance to be easily accessed once a particularDial instance is identified.

[0194] DIDS 1202 further includes a parent field 1232 that, in the caseof an IDial, CDial or LDial, contains a parent pointer 1233 pointing tothe DIDS 1202 of the higher-level Dial instance, if any, having anoutput logically connected to the input of the corresponding Dialinstance. In the case of a Dial group, parent pointer 1233 points to theDIDS 1202 of the higher-level Dial group, if any, that hierarchicallyincludes the present Dial group. If the Dial instance corresponding to aDIDS 1202 is a top-level Dial and does not belong to any Dial group,parent pointer 1233 in parent field 1232 is a NULL pointer. It should benoted that a Dial can be a top-level Dial, but still belong to a Dialgroup. In that case, parent pointer 1233 is not NULL, but rather pointsto the DIDS 1202 of the Dial group containing the top-level Dial.

[0195] Thus, parent fields 1232 of the DIDSs 1202 in configurationdatabase 814 collectively describe the hierarchical arrangement of Dialentities and Dial groups that are instantiated in a digital design. Asdescribed below, the hierarchical information provided by parent fields1232 advantageously enables a determination of the input value of anytop-level Dial given the configuration values of the configurationlatches ultimately controlled by that top-level Dial.

[0196] Instance name field 1234 of DIDS 1202 gives the fully qualifiedinstance name of the Dial instance described by DIDS 1202 from thetop-level design entity of the digital design. For Dial instancesassociated with the top-level entity, instance name field 1234preferably contains a NULL string.

[0197] Finally, DIDS 1202 includes an output pointer array 1236containing pointers 1238 a-1238 n pointing to data structures describingthe lower-level instantiations associated with the corresponding Dialinstance or Dial group instance. Specifically, in the case of IDials andLDials, output pointers 12

[0198] latch data structures 1204 corresponding to the configurationlatches coupled to the Dial instance. For non-split IDials, theconfiguration latch entity referred to by output pointer 1238 a receivesthe high order bit of the integer input value, and the configurationlatch entity referred to by output pointer 1238 n receives the low orderbit of the integer input value. In the case of a CDial, output pointers1238 refer to other DIDSs 1202 corresponding to the Dial instancescontrolled by the CDial. For Dial groups, output pointers 1238 refer tothe top-level Dial instances or Dial group instances hierarchicallyincluded within the Dial group instance corresponding to DIDS 1202.

[0199] Configuration database 814 further includes a respective latchdata structure 1204 for each configuration latch in simulationexecutable model 816 to which an output of an LDial or IDial islogically coupled. Each latch data structure 1204 includes a parentfield 1240 containing a parent pointer 1242 to the DIDS 1200 of theLDial or IDial directly controlling the corresponding configurationlatch. In addition, latch data structure 1204 includes a latch namefield 1244 specifying the hierarchical latch name, relative to theentity containing the Dial instantiation identified by parent pointer1242. For example, if an LDial X having an instantiation identifiera.b.c refers to a configuration latch having the hierarchical name“a.b.c.d.latch1”, latch name field 1244 will contain the string“d.latch1”. Prepending contents of an instance name field 1234 of theDIDS 1202 identified by parent pointer 1242 to the contents of a latchname field 1244 thus provides the fully qualified name of any instanceof a given configuration latch configurable utilizing configurationdatabase 814. 101691 Still referring to FIG. 12, as noted above,configuration database 814 includes top-level pointer array 1206, andoptionally, Dial pointer array 1208 and latch pointer array 1210.Top-level pointer array 1206 contains top-level pointers 1250 that, foreach top-level Dial and each top-level Dial group, points to anassociated DIDS 1202 for the top-level entity instance. Dial pointerarray 1208 includes Dial pointers 1252 pointing to each DDDS 1200 inconfiguration database 814 to permit indirect access to particular Dialinstances through Dial and/or entity names. Finally, latch pointer array1210 includes latch pointers 1254 pointing to each latch data structure1204 within configuration database 814 to permit easy access to allconfiguration latches.

[0200] Once a configuration database 814 is constructed, the contents ofconfiguration database 814 can be loaded into volatile memory, such assystem memory 18 of data processing system 8 of FIG. 1, in order toappropriately configure a simulation model for simulation. In general,data structures 1200, 1202, 1204 and 1206 can be loaded directly intosystem memory 18, and may optionally be augmented with additionalfields, as described below. However, as noted above, if it is desirablefor the non-volatile image of configuration database 814 to be compact,it is helpful to generate additional data structures, such as Dialpointer array 1208, latch pointer array 1210 and instance pointer arrays1226, in the volatile configuration database image in system memory 18.

[0201] Referring now to FIG. 13, there is depicted a high level logicalflowchart of a method by which configuration database 814 is expandedwithin volatile memory of a data processing system, such as systemmemory 18 of data processing system 8. Because FIG. 13 depicts logicalsteps rather than operational steps, it should be understood that manyof the steps illustrated in FIG. 13 may be performed concurrently or ina different order than that shown.

[0202] As illustrated, the process begins at block 1300 and thenproceeds to block 1302, which illustrates data processing system 6copying the existing data structures within configuration database 814from non-volatile storage (e.g., disk storage or flash memory) intovolatile system memory 18. Next, at block 1304, a determination is madewhether all top-level pointers 1250 within top-level pointer array 1206of configuration database 814 have been processed. If so, the processpasses to block 1320, which is discussed below. If not, the processproceeds to block 1306, which illustrates selection from top-level array1206 of the next top-level pointer 1250 to be processed.

[0203] A determination is then made at block 1308 of whether or notparent pointer 1233 within the DIDS 1202 identified by the selectedtop-level pointer 1250 is a NULL pointer. If not, which indicates thatthe DIDS 1202 describes a top-level Dial belonging to a Dial group, theprocess returns to block 1304, indicating that the top-level Dial andits associated lower-level Dials will be processed when the Dial groupto which it belongs is processed.

[0204] In response to a determination at block 1308 that the parentpointer 1233 is a NULL pointer, data processing system 8 creates aninstance pointer 1228 to the DIDS 1202 in the instance array 1226 of theDDDS 1200 to which definition pointer 1231 in definition field 1230 ofDIDS 1202 points, as depicted at block 1310. Next, at block 1312, dataprocessing system 8 creates a Dial pointer 1252 to the DDDS 1200 of thetop-level Dial within Dial pointer array 1208, if the Dial pointer 1252is not redundant. In addition, as shown at block 1314, data processingsystem 8 creates a latch pointer 1254 within latch pointer array 1210pointing to each latch data structure 1204, if any, referenced by anoutput pointer 1238 of the DIDS 1202 of the top-level Dial. As shown atblock 1316, each branch at each lower level of the Dial tree, if any,headed by the top-level Dial referenced by the selected top-levelpointer 1250 is then processed similarly by performing the functionsillustrated at block 1310-1316 until a latch data structure 1204terminating that branch is found and processed. The process then returnsto block 1304, representing the processing of each top-level pointer1250 within top-level pointer array 1206.

[0205] In response to a determination at block 1304 that all top-levelpointers 1250 have been processed, the process illustrated in FIG. 13proceeds to block 1320. Block 1320 illustrates the creation of a Setfield 1239 in each DIDS 1320 in the configuration database. Set field1239 is a Boolean-valued field that in initialized to FALSE and isupdated to TRUE when the associated Dial instance is explicitly set. Inaddition, as depicted at block 1322, data processing system 8 creates alatch value field 1246 and latch set field 1248 in each latch datastructure 1204 to respectively indicate the current set value of theassociated configuration latch and to indicate whether the configurationlatch has been explicitly set. Although the creation of the three fieldsindicated at block 1320-1322 is illustrated separately from theprocessing depicted at blocks 1304-1316 for purposes of clarity, it willbe appreciated that it is more efficient to create Dial set field 1239as each DIDS 1202 is processed and to create latch value and latch setfields 1246, 1248 as the latch data structures 1204 at the bottom ofeach Dial tree are reached. The process of loading the configurationdatabase into volatile memory thereafter terminates at block 1324.

[0206] With the configuration database loaded into volatile memory, asimulation model can be configured and utilized to simulate a digitaldesign through the execution of simulation software. With reference toFIG. 14, there is illustrated a block diagram depicting the contents ofsystem memory 18 (FIG. 1) during a simulation run of a simulation model.As shown, system memory 18 includes a simulation model 1400, which is alogical representation of the digital design to be simulated, as well assoftware including configuration APIs 1406, a simulator 1410 and an RTX(Run Time eXecutive) 1420.

[0207] Simulator 1410 loads simulation models, such as simulation model1400, into system memory 18. During a simulation run, simulator 1410resets, clocks and evaluates simulation model 1400 via various APIs1416. In addition, simulator 1410 reads values in simulation model 1400utilizing GETFAC API 1412 and writes values to simulation model 1400utilizing PUTFAC API 1414. Although simulator 1410 is implemented inFIG. 14 entirely in software, it will be appreciated in what followsthat the simulator can alternatively be implemented at least partiallyin hardware.

[0208] Configuration APIs 1406 comprise software, typically written in ahigh level language such as C or C++, that support the configuration ofsimulation model 1400. These APIs, which are dynamically loaded bysimulator 1410 as needed, include a first API that loads configurationmodel 814 from non-volatile storage and expands it in the mannerdescribed above with reference to FIG. 13 to provide a memory image ofconfiguration database 1404. Configuration APIs 1406 further includeadditional APIs to access and manipulate configuration database 1404, asdescribed in detail below.

[0209] RTX 1420 controls simulation of simulation models, such assimulation model 1400. For example, RTX 1420 loads test cases to applyto simulation model 1400. In addition, RTX 1420 delivers a set of APIcalls to configuration APIs 1406 and the APIs provided by simulator 1410to initialize, configure, and simulate operation of simulation model1400. During and after simulation, RTX 1420 also calls configurationAPIs 1406 and the APIs provided by simulator 1410 to check for thecorrectness of simulation model 1400 by accessing various Dials,configuration latches, counters and other entities within simulationmodel 1400.

[0210] RTX 1420 has two modes by which it accesses Dials instantiatedwithin simulation model 1400: interactive mode and batch mode. Ininteractive mode, RTX 1420 calls a first set of APIs to read from orwrite to one or more instances of a particular Dial within configurationdatabase 1404. The latch value(s) obtained by reference to configurationdatabase 1404 take immediate effect in simulation model 1400. In batchmode, RTX 1420 calls a different second set of APIs to read or writeinstantiations of multiple Dials in configuration database 1404 and thenmake any changes to simulation model 1400 at the same time.

[0211] In either interactive or batch mode, RTX 1420 must employ somesyntax in its API calls to specify which Dial or Dial group instanceswithin simulation model 1400 are to be accessed. Although a number ofdifferent syntaxes can be employed, including conventional regularexpressions employing wildcarding, in an illustrative embodiment thesyntax utilized to specify Dial or Dial group instances in API calls issimilar to the compact expression hereinbefore described. A keydifference between the compact expressions discussed above and thesyntax utilized to specify Dial or Dial group instances in the RTX APIcalls is that, in the illustrative embodiment, Dial and Dial groupinstances are specified in the RTX API calls by reference to thetop-level design entity of simulation model 1400 rather than relative tothe design entity in which the Dial or Dial group is specified.

[0212] In the illustrative embodiment, each RTX API call targeting oneor more Dial or Dial group instances in simulation model 1400 specifiesthe Dial or Dial group instances utilizing two parameters: an instancequalifier and a dialname qualifier. To refer to only a single Dial orDial group instantiation, the instance qualifier takes the form“a.b.c.d”, which is the hierarchical instantiation identifier of thedesign entity in which the single Dial or Dial group instantiationoccurs. To refer to multiple Dial or Dial group instances, the instancequalifier takes the form “a.b.c.[X]”, which identifies allinstantiations of entity X within the scope of entity instance a.b.c. Inthe degenerate form, the instance qualifier may simply be “[X]”, whichidentifies all instantiations of entity X anywhere within simulationmodel 1400.

[0213] The dialname qualifier preferably takes the form“Entity.dialname”, where “Entity” is the design entity in which the Dialor Dial group is instantiated and “dialname” is the name assigned to theDial or Dial group in its configuration specification statement. Ifbracketed syntax is employed to specify the instance qualifier, the“Entity” field can be dropped from the dialname qualifier since it willmatch the bracketed entity name.

[0214] Referring now to FIG. 15 there is depicted a high level logicalflowchart of an exemplary process by which configuration APIs 1406locate particular Dial or Dial group instances in configuration database1404 based upon an instance qualifier and dialname qualifier pair inaccordance with the present invention. As shown, the process begins atblock 1500 in response to receipt by a configuration API 1406 of an APIcall from RTX 1420 containing an instance qualifier and a dialnamequalifier as discussed above. In response to the API call, theconfiguration API 1406 enters configuration database 1404 at Dialpointer array 1208, as depicted at block 1502, and utilizes Dialpointers 1252 to locate a DDDS 1200 having a name field 1222 thatexactly matches the specified dialname qualifier, as illustrated atblock 1504.

[0215] Next, at block 1506, the configuration API 1406 determineswhether the instance qualifier employs bracketed syntax, as describedabove. If so, the process passes to block 1520, which is describedbelow. However, if the instance qualifier does not employ bracketedsyntax, the configuration API 1406 follows the instance pointers 1228 ofthe matching DDDS 1200 to locate the single DIDS 1202 having an instancename field 1234 that exactly matches the specified instance qualifier.As indicated at blocks 1510-1512, if no match is found, the processterminates with an error. However, if a matching DIDS 1202 is located, atemporary “result” pointer identifying the single matching DIDS 1202 iscreated at block 1524. The process thereafter terminates at block 1526.

[0216] Returning to block 1520, if bracketed syntax is employed, theconfiguration API 1406 utilizes instance pointers 1228 of the matchingDDDS 1200 to locate one or more DIDSs 1202 of Dial or Dial groupinstances within the scope specified by the prefix portion of theinstance identifier preceding the bracketing. That is, a DIDS 1202 issaid to “match” if the instance name field 1234 of the DIDS 1202contains the prefix portion of the instance qualifier. Again, if nomatch is found, the process passes through block 1522 and terminateswith an error at block 1512. However, if one or more DIDSs 1202 “match”the instance qualifier, temporary result pointers identifying thematching DIDSs 1202 are constructed at block 1524. The process shown inFIG. 15 thereafter terminates at block 1526.

[0217] With reference now to FIG. 16A, there is illustrated a high levellogical flowchart of an exemplary process by which RTX 1420 reads avalue of one or more Dial instances in interactive mode, in accordancewith the present invention. As shown, the process begins at block 1600in response to receipt by a configuration API 1406 of a read_Dial( ) APIcall by RTX 1420. As indicated at block 1602, a configuration API 1406responds to the read Dial( ) API call by locating within configurationdatabase 1404 one or more DIDSs 1202 of Dial instances responsive to theAPI call utilizing the process described above with reference to FIG.15.

[0218] The process then enters a loop at block 1604 in which each of thetemporary result pointers generated by the process of FIG. 15 isprocessed. If all of the result pointers returned by the process of FIG.15 have been processed, the process passes to block 1640, which isdescribed below. If not, the process proceeds from block 1606 to block1608, which illustrates the configuration API 1406 selecting a nextresult pointer to be processed. Next, at block 1608, the configurationAPI 1406 determines by reference to type field 1220 of the DDDS 1200associated with the DIDS 1202 identified by the current result pointerwhether the DIDS 1202 corresponds to a Dial group. If so, the processillustrated in FIG. 16A terminates with an error condition at block 1610indicating that RTX 1420 has utilized the wrong API call to read a Dialinstance.

[0219] In response to a determination at block 1608 that the DIDS 1202identified by the current result pointer does not correspond to a Dialgroup instance, the process proceeds to block 1620. Block 1620 depictsconfiguration API 1406 utilizing output pointers 1238 of the DIDS 1202(and those of any lower-level DIDS 1202 in the Dial tree) to build adata set containing the latch names from the latch name fields 1244 oflatch data structures 1204 corresponding to all configuration latchesultimately controlled by the Dial instance specified in the API call.Next, as depicted at block 1622, the configuration API 1406 makes one ormore API calls to GETFAC( ) API 1412 of simulator 1410 to obtain fromsimulation model 1400 the latch values of all of the configurationlatches listed in the data set constructed at block 1620.

[0220] Configuration API 1406 then verifies the latch values obtainedfrom simulation model 1400 by reference to configuration database 1404,as shown at block 1624. In order to verify the latch values,configuration API 1406 utilizes mapping tables 1224 to propagate thelatch values up the Dial tree from the corresponding latch datastructures through intermediate DIDSs 1202, if any, until an input valuefor the requested Dial instance is determined. If at any point in thisverification process, a Dial instance's output value generated by theverification process does not correspond to one of the legal valuesenumerated in its mapping table 1224, an error is detected at block1626. Accordingly, the latch values read from simulation model 1400 andan error indication are placed in a result data structure, asillustrated at block 1630. If no error is detected, the Dial input valuegenerated by the verification process and a success indication areplaced in the result data structure, as shown at block 1628.

[0221] As indicated by the process returning to block 1604, theabove-described process is repeated for each temporary result pointerreturned by the process of FIG. 15. Once all result pointers have beenprocessed, the process passes from block 1604 to blocks 1640-1642, whichillustrate the configuration API 1406 returning the result datastructure to RTX 1420 and then terminating.

[0222] RTX 1420 reads Dial instances in interactive mode utilizing themethod of FIG. 16A, for example, to initialize checkers that monitorportions of simulation model 1400 during simulation runs. The Dialsettings of interest include not only those of top-level Dial instances,but also those of lower-level Dial instances affiliated with theportions of the simulation model 1400 monitored by the checkers.

[0223] Referring now to FIG. 16B, there is illustrated a high levellogical flowchart of an exemplary process by which RTX 1420 reads avalue of one or more Dial group instances in interactive mode, inaccordance with the present invention. As can be seen by comparison ofFIGS. 16A and 16B, the process of reading a Dial group instance issimilar to the process of reading a Dial instance, but returns the valueof one or more top-level Dial instances of possibly different Dialentities rather than one or more instances of the same Dial entity.

[0224] As shown, the process shown in FIG. 16B begins at block 1650 inresponse to receipt by a configuration API 1406 of a read_Dial_group( )API call by RTX 1420. As indicated at block 1652, a configuration API1406 responds to the read_Dial_group( ) API call by locating withinconfiguration database 1404 one or more DIDSs 1202 of Dial groupinstances responsive to the API call utilizing the process describedabove with reference to FIG. 15.

[0225] The process then enters a loop at block 1654 in which each of thetemporary result pointers generated by the process of FIG. 15 isprocessed. If all of the result pointers returned by the process of FIG.15 have been processed, the process passes to block 1680, which isdescribed below. If not, the process proceeds from block 1654 to block1656, which illustrates the configuration API 1406 selecting a nextresult pointer to be processed. Next, at block 1658, the configurationAPI 1406 identifies and creates temporary pointers to all of thetop-level Dial instances belonging to the Dial group instancecorresponding to the DIDS 1202 referenced by the current result pointer.The top-level Dial instances are identified by locating thehighest-level DIDS 1202 for each output pointer 1238 for which the typefield 1220 in the associated DDDS 1220 specifies a type other than Dialgroup. In other words, the configuration API 1406 may have to searchdown through one or more hierarchical Dial groups to locate the relevanttop-level Dial instances.

[0226] The process illustrated in FIG. 16B then enters a loop beginningat block 1659 in which each of the top-level Dial instances belonging tothe Dial group corresponding to the Dial group DIDS 1202 referenced bythe current result pointer is individually processed to obtain thevalue(s) of the top-level Dial instance(s). The process next proceeds toblock 1660, which depicts configuration API 1406 utilizing outputpointers 1238 of the DIDS 1202 of the first (or next) top-level Dialinstance (and those of any lower-level DIDS 1202 in the Dial tree) tobuild a data set containing the latch names from the latch name fields1244 of latch data structures 1204 corresponding to all configurationlatches ultimately controlled by the top-level Dial instance. Next, asdepicted at block 1662, the configuration API 1406 makes one or more APIcalls to GETFAC( ) API 1412 of simulator 1410 to obtain from simulationmodel 1400 the latch values of all of the configuration latches listedin the data set constructed at block 1660.

[0227] At block 1664, configuration API 1406 then verifies the latchvalues obtained from simulation model 1400 by reference to configurationdatabase 1404, utilizing the same technique described above withreference to block 1624 of FIG. 16A. If at any point in thisverification process, a Dial instance's output value generated by theverification process does not correspond to one of the legal valuesenumerated in its mapping table 1224, an error is detected at block1666. Accordingly, the latch values read from simulation model 1400 andan error indication are placed in a result data structure, asillustrated at block 1670. If no error is detected, the Dial input valuegenerated by the verification process and a success indication areplaced in the result data structure, as shown at block 1668.

[0228] Following either block 1668 or block 1670, the process returns toblock 1659, which represents a determination of whether or not alltop-level Dials belonging to the Dial group corresponding to the DIDS1202 referenced by the current result pointer have been processed. Ifnot, the process returns to block 1660, which has been described.However, if all top-level Dials have been processed, the process returnsto block 1654, which illustrates a determination of whether or not allresult pointers have been processed. If not, the next result pointer isprocessed at block 1656 and following blocks, which have been described.If, however, all result pointers have been processed, the process passesto block 1680-1682, which illustrates the configuration API 1406returning the result data structure to RTX 1420 and then terminating.

[0229] Reading Dial and Dial group instances in a batch mode of RTX 1420is preferably handled by configuration APIs 1406 in the same manner asinteractive mode, with one exception. Whereas in interactive mode latchvalues are always read from simulation model 1440 via calls to GETFAC( )API 1412 at blocks 1622 and 1662, in batch mode a latch value ispreferably obtained from latch value field 1246 of a latch datastructure 1204 in configuration database 1404 if latch set field 1248indicates that the corresponding configuration latch has been set. Ifthe configuration latch has not been set, the latch value is obtainedfrom simulation model 1440 by a call to GETFAC( ) API 1412. Thisdifference ensures that Dial settings made in batch mode, which may notyet have been reflected in simulation model 1400, are correctlyreported.

[0230] With reference now to FIG. 17A, there is illustrated a high levellogical flowchart of an exemplary process by which an RTX sets a Dialinstance in an interactive mode in accordance with the presentinvention. The process begins at block 1700 in response to receipt by aconfiguration API 1406 of a set_Dial( ) API call from RTX 1420. Inresponse to the set_Dial( ) API call, the configuration API 1406 firstlocates and generates temporary result pointers pointing to the DIDS1202 of the Dial instance(s) specified in the set_Dial( ) API callutilizing the technique described above with reference to FIG. 15, asillustrated at block 1702. Next, the configuration API 1406 determinesat block 1704 whether or not all of the temporary result pointers pointto DIDSs 1202 of top-level Dial instances. This determination can bemade, for example, by examining the parent pointer 1233 of each suchDIDS 1202 (and that of any higher level DIDS 1202 linked by a parentpointer 1233) and the type fields 1220 of the associated DDDSs 1200. TheDIDS 1202 of a top-level Dial instance will have either a NULL parentpointer 1233 or a non-NULL parent pointer 1233 pointing to another DIDS1202 that the type field 1220 of the associated DDDS 1200 indicatesrepresents a Dial group. If any of the DIDSs 1202 referenced by theresult pointers does not correspond to a top-level Dial instance, theprocess terminates at block 1708 with an error condition.

[0231] In response to a determination at block 1704 that all of theDIDSs 1202 referenced by the result pointers correspond to top-levelDial instances, a further determination is made at block 1706 whether ornot the specified value to which the Dial instance(s) are to be set isone of the values specified in the mapping table 1224 of the associatedDDDS 1200. If not, the process terminates with an error at block 1708.However, in response to a determination at block 1706 that the specifiedvalue to which the Dial instance(s) are to be set is one of the legalvalues, the process enters a loop including blocks 1710-1716 in whicheach result pointer is processed to set a respective Dial instance.

[0232] At block 1710, configuration API 1406 determines whether or notall result pointers have been processed. If so, the process terminatesat block 1720. If, however, additional result pointers remain to beprocessed, the next result pointer to be processed is selected at block1712. Next, at block 1714, configuration API 1406 propagates the Dialsetting specified in the set_Dial( ) API call down the Dial tree headedby the top-level Dial instance associated with the DIDS 1202 referencedby the current result pointer. In order to propagate the desired Dialsetting, mapping table 1224 in the DDDS 1200 associated with the DIDS1202 referenced by the current result pointer is first referenced, ifnecessary, (i.e., for CDials and LDials) to determine the output valuesfor each of output pointers 1238 in the output pointer array 1236 of theDIDS 1202 referenced by the current result pointer. These output valuesare propagated down the Dial tree as the input values of the nextlower-level Dial instances, if any, corresponding to the DIDSs 1202referenced by output pointers 1238. This propagation continues until alatch value is determined for each configuration latch terminating theDial tree (which are represented in configuration database 1404 by latchdata structures 1204). As shown at block 1716, as each latch value for aconfiguration latch is determined, the configuration API 1406 makes acall to PUTFAC( ) API 1414 to set the configuration latch in simulationmodel 1400 to the determined value utilizing the latch name specifiedwithin the latch name field 1244 of the corresponding latch datastructure 1204.

[0233] Thereafter, the process returns to block 1710, which representsthe processing of the top-level Dial corresponding to the next resultpointer. After all result pointers are processed, the process terminatesat block 1720.

[0234] Referring now to FIG. 17B, there is depicted a high level logicalflowchart of an illustrative process by which an RTX sets a Dial groupin an interactive mode in accordance with the present invention. Theprocess begins at block 1730 in response to receipt by a configurationAPI 1406 of a set_Dial_group( ) API call from an RTX 1420. In responseto the set_Dial_group( ) API call, the configuration API 1406 firstlocates and generates temporary result pointers pointing to the DIDS1202 of the Dial group instance(s) specified in the set_Dial_group( )API call utilizing the technique described above with reference to FIG.15, as depicted at block 1732. Next, the configuration API 1406determines at block 1734 whether or not all of the temporary resultpointers point to DIDSs 1202 of top-level Dial group instances. Thisdetermination can be made, for example, by examining the parent pointer1233 of each such DIDS 1202 to ascertain whether the parent pointer 1233is NULL. If any of the DIDSs 1202 referenced by the result pointers doesnot correspond to a top-level Dial group (i.e., has a non-NULL parentpointer 1233), the process terminates at block 1736 with an errorcondition.

[0235] In response to a determination at block 1734 that each of theDIDSs 1202 referenced by the result pointers corresponds to a top-levelDial group, the process passes to blocks 1738-1740. Block 1738illustrates configuration API 1406 locating all of the top-level Dialinstances within each Dial group for which the corresponding DIDS 1202is referenced by a result pointer. Then, as depicted at block 1740, theconfiguration API 1406 determines whether or not the specified value towhich each top-level Dial instance is to be set is one of the valuesspecified in the mapping table 1224 of the corresponding DDDS 1200. Ifnot, the process terminates with an error at block 1736.

[0236] In the illustrated embodiment, the prevalidation stepsillustrated at blocks 1734, 1738 and 1740 are performed prior to settingany Dial instances because it is deemed preferable to implement settinga Dial group instance as an atomic operation that either successfullysets all relevant top-level Dial instances or completely fails. In thismanner, a complex condition in which some top-level Dial instanceswithin the Dial group instance are set and others are not can beavoided.

[0237] In response to a determination at block 1740 that the specifiedvalue to which each top-level Dial instance is to be set is one of thelegal values, the process enters a loop including blocks 1750-1756 inwhich each result pointer is processed to set the top-level Dialinstance(s) belonging to each Dial group instance.

[0238] At block 1750, the configuration API 1406 determines whether ornot all result pointers have been processed. If so, the processterminates at block 1760. If, however, additional result pointers remainto be processed, the next result pointer to be processed is selected atblock 1752. Next, at block 1754, configuration API 1406 propagates theDial setting specified for each top-level Dial in the set_Dial group( )API call down the Dial trees of the top-level Dial instances belongingto the Dial group instance corresponding to the DIDS 1202 referenced bythe current result pointer. The propagation of Dial settings down theDial trees is performed in the same manner discussed above withreference to block 1714 of FIG. 17A. As shown at block 1756, as eachlatch value for a configuration latch is determined, the configurationAPI 1406 makes a call to PUTFAC( ) API 1414 to set the configurationlatch in simulation model 1400 to the determined value utilizing thelatch name specified within the latch name field 1244 of thecorresponding latch data structure 1204. Thereafter, the process returnsto block 1750, which represents the processing of the top-level Dialcorresponding to the next result pointer, if any.

[0239] With reference now to FIG. 18, there is illustrated a high levellogical flowchart of an exemplary method of setting Dial and Dial groupinstances in batch mode in accordance with the present invention. Asillustrated, the process begins at block 1800 and thereafter proceeds toblock 1802, which illustrates RTX 1420 initializing configurationdatabase 1404 by calling a configuration API 1406 (e.g., start_batch( ))in order to initialize configuration database 1404. The start_batch( )API routine initializes configuration database 1404, for example, bysetting each Dial set field 1239 and latch set field 1248 inconfiguration database 1404 to FALSE. By resetting all of the “set”fields in configuration database 1404, the Dials and configurationlatches that are not set by the current batch mode call sequence can beeasily detected, as discussed below.

[0240] Following initialization of configuration database 1404, RTX 1420issues a batch mode set_Dial( ) or set Dial_group( ) API call to entersettings for Dial instances and their underlying configuration latchesinto configuration database 1404. A configuration API 1406 responds tothe API call in the same manner described above with respect to FIG. 17A(for setting Dial instances) or FIG. 17B (for setting Dial groupinstances), with two exceptions. First, when any top-level orlower-level Dial instances are set, whether as a result of a set_Dial( )or set_Dial_group( ) API call, the Dial set field 1239 of thecorresponding DIDS 1202 is set to TRUE. Second, no latch values arewritten to simulation model 1400 by the “set” API routines, asillustrated at blocks 1716 and 1756 of FIGS. 17A-17B. Instead, the latchvalues are written into latch value fields 1246 of the latch datastructure 1204 corresponding to each affected configuration latch, andthe latch set field 1248 is updated to TRUE. In this manner, the Dialinstances and configuration latches that are explicitly set by the APIcall can be readily identified during subsequent processing.

[0241] Following block 1804, the process passes to blocks 1806-1808,which illustrate RTX 1420 calling an end_batch( ) API routine amongconfiguration APIs 1406 to complete the batch mode access. Asillustrated at block 1806, the end_batch( ) API routine first appliesdefault values, if any, to any Dial instances not explicitly set atblock 1804, if a default mode is enabled (e.g., through a parameter ofthe end_batch( ) API call or an operational parameter of RTX 1420). Toapply default values, the end_batch( ) API routine locates all unsettop-level Dial instances (i.e., those for which Dial set field 1239 isFALSE) in configuration database 1404 and applies the default value, ifany, specified in the default field 1229 of the associated DDDS 1200.These default values are propagated down the Dial tree of each affectedtop-level Dial and utilized to set latch value fields 1246, Dial setfield 1239 and latch set field 1248 in the manner described above withreference to block 1804. The end_batch( ) API routine then traverses theDial tree of each top-level CDial that remains unset following theapplication of default values to top-level Dials and applies the defaultvalue of the next highest-level Dial instance in each branch of the Dialtree that has a specified default value. Again, these default values arepropagated down the Dial tree of each affected lower-level Dial andutilized to set latch value fields 1246, Dial set field 1239 and latchset field 1248 in the manner described above with reference to block1804. This methodology of applying default values allows default valueshigher in a Dial tree to have precedence over default values lower inthe Dial tree.

[0242] After default values have been optionally applied as illustratedat block 1806, the end_batch( ) API routine utilizes latch pointer array1210 to examine each latch data structure 1204 in configuration database1404. For each latch data structure 1204 in which latch set field 1248has the value TRUE, the end batch( ) API routine issues a call toPUTFAC( ) API 1414 of simulator 1410 to update simulation model 1400with the latch value contained in latch value field 1246. Thereafter,the batch process terminates at block 1810.

[0243] Configuration APIs 1406 preferably further include afind_unset_latch( ) API that, following a batch mode setting of Dial orDial group instances in configuration database 1404, audits all of thelatch data structures 1204 in configuration database 1204 by referenceto latch pointer array 1210 in order to detect configuration latchesthat have not been configured by an explicit or default setting (i.e.,those having latch set field 1248 set to FALSE). For each such unsetconfiguration latch, the find_unset_latch( ) API preferably returns thefully qualified instance name of the configuration latch from latch namefield 1244 in the corresponding latch data structure 1204 and the fullyqualified instantiation identifier of the top-level Dial instance thatcontrols the unset latch. The find_unset_latch( ) API thus provides anautomated mechanism for a user to verify that all Dial and latchinstances requiring an explicit or default setting are properlyconfigured for a simulation run.

[0244] Configuration APIs 1406 preferably further include a check_model() API that, when called, utilizes top-level pointer array 1206 to verifyby reference to the appropriate mapping tables 1224 that each top-levelCDial and LDial instance in simulation model 1400 is set to one of itslegal values. Any top-level LDial or CDial set to an illegal value isreturned by the check_model( ) API.

[0245] The Dial and Dial group primitives introduced by the presentinvention can be employed not only to configure a simulation model of adigital design as described above, but also to configure hardwarerealizations of the digital design for laboratory testing and customeruse. In accordance with an important aspect of the present invention,hardware realizations of the digital design are configured by referenceto a hardware configuration database, which like configuration databases814 and 1404 discussed above, is derived from configurationspecification statements coded by the designers. In this manner,continuity in configuration methodology exists from design, throughsimulation and laboratory testing, to commercial deployment of a digitaldesign.

[0246] Referring now to FIG. 19, there is illustrated a high-level blockdiagram of a laboratory testing system for testing and debugginghardware realizations of one or more digital designs in accordance withan embodiment of the present invention. As illustrated, the laboratorytesting system 1900 includes a data processing system 1902, which isintended for commercial sale and deployment. For laboratory testing anddebugging, data processing system 1902 is coupled by a test interface1903 to a workstation computer 1904 that communicates with dataprocessing system 1902 via test interface 1903 to configure the variouscomponents of data processing system 1902 for proper operation. Whencommercially deployed, data processing system 1902 includes theillustrated components, but is not typically coupled to workstationcomputer 1904 by test interface 1903.

[0247] Data processing system 1902 may be, for example, a multiprocessorcomputer system, such as data processing system 6 of FIG. 1. As such,data processing system 1902 includes multiple integrated circuit chips1910 representing the various processing units, controllers, bridges andother components of a data processing system. As is typical ofcommercial data processing systems, data processing system 1902 maycontain multiple instances of some integrated circuit chips, such asintegrated circuit chips 1910 a, and single instances of otherintegrated circuit chips, such as integrated circuit chip 1910 n.

[0248] In addition to their respective functional logic, integratedcircuit chips 1910 each have a respective test port controller 1912 thatsupports external configuration of the integrated circuit chip utilizingmultiple scan chains, as discussed in detail below with reference toFIG. 20. To permit such external configuration, each test portcontroller 1912 is coupled by a test access port (TAP) 1914 to a serviceprocessor 1920 within data processing system 1902.

[0249] Service processor 1920 is a general-purpose or special-purposecomputer system utilized to initialize and configure data processingsystem 1902, for example, at power-on or in response to a reboot.Service processor 1920 includes at least one processing unit 1922 a forexecuting software instructions, a flash read-only memory (ROM) 1924providing non-volatile storage for software and data, an I/O interface1926 a interfacing service processor 1920 with test port controllers1912 and workstation computer 1904, and a volatile memory 1928 a thatbuffers instructions and data for access by processing unit 1922 a.

[0250] Among the software and data stored in flash ROM 1924 is systemfirmware 1930 a. System firmware 1930 a is executed by processing unit1922 a of service processor 1920 at power-on to sequence power tointegrated circuit chips 1910, perform various initialization proceduresand tests, synchronize communication between integrated circuit chips1910, and initiate operation of the functional clocks. System firmware1930 a controls the startup behavior of integrated circuit chips 1910 bycommunication via test access ports 1914.

[0251] In addition to system firmware 1930 a, flash ROM 1924 storeshardware (HW) configuration APIs 1934 a and a HW configuration database1932 a describing integrated circuit chips 1910. As described below,during commercial deployment, processing unit 1922 a calls various HWconfiguration APIs 1934 a to access HW configuration database 1932 a inorder to appropriately configure integrated circuits 1910 via I/Ointerface 1926 a and TAPs 1914.

[0252] Workstation computer 1904, which may be implemented, for example,as a multiprocessor computer system like data processing system 6 ofFIG. 1, includes many components that are functionally similar to thoseof service processor 1920. Accordingly, like reference numeralsdesignate processing unit 1922 b, volatile memory 1928 b, I/O interface1926 b, and the system firmware 1930 b, HW configuration database 1932b, and HW configuration APIs 1934 b residing in non-volatile storage1940 (e.g., disk storage). It will be appreciated by those skilled inthe art that, because the system firmware 1930 b, HW configurationdatabase 1932 b and HW configuration APIs 1934 b residing innon-volatile storage 1940 are specifically designed to initialize andconfigure data processing system 1902 in the context of laboratorytesting and debugging, they may have smaller, larger or simply differentfeature sets and capabilities than the corresponding software and datawithin flash ROM 1924.

[0253] During laboratory testing and debugging, workstation computer1904 assumes most of the functions of service processor 1920. Forexample, workstation computer 1904 initializes and configures dataprocessing system 1902 by executing system firmware 1930 b and variousHW configuration APIs 1934 b in order to generate various I/O commands.These I/O commands are then communicated to data processing system 1902via test interface 1903 and I/O interfaces 1926 a and 1926 b. Systemfirmware 1930 a, which executes within service processor 1920 in a“bypass mode” in which most of its native functionality is disabled,responds to these external I/O commands by issuing them to integratedcircuit chips 1910 via test access ports 1914 in order to initialize andconfigure integrated circuit chips 1910.

[0254] With reference now to FIG. 20, there is illustrated a moredetailed block diagram of an exemplary integrated circuit chip 1910 inaccordance with the present invention. As noted above, integratedcircuit chip 1910 includes a test port controller 2000 supportingexternal communication with I/O interface 1926 of service processor 1920of FIG. 19 and control of various internal functions of integratedcircuit chip 1910, including the operation of functional clock 2002 andscan clock 2010. Integrated circuit chip 1910 further includesfunctional logic (not explicitly illustrated) comprising the digitalintegrated circuitry that performs the “work” the integrated circuit isdesigned to do, for example, processing software instructions, inresponse to the clock pulses of functional clock 2002. Throughout thefunctional logic is distributed a plurality of functional latches 2004that, during normal functional operation of the functional logic (i.e.,when functional clock 2002 clocks the functional logic), hold bitsrepresenting the dynamic state of the functional logic and data and/orinstructions. These functional latches 2004 include those that hold modeand configuration bits utilized to configure the functional logic in adesired configuration.

[0255] As shown, groups of functional latches 2004 are interconnected toform multiple test scan chains 2006 and multiple SCOM (scancommunication) chains 2008. Although not illustrated for the sake ofclarity, some functional latches 2004 are, in practice, members of botha test scan chain 2006 and an SCOM chain 2008. The test scan chains 2006are utilized to scan bits into functional latches 2004 in response topulses of scan clock 2010, and the SCOM chains 2008 are utilized to scanbits into functional latches 2004 in response to pulses of functionalclock 2002. Functional clock 2002 and scan clock 2010 do not both outputpulses at the same time to prevent a conflict between values loaded intofunctional latches 2004.

[0256] As depicted, each functional latch 2004 in a test scan chain 2006includes at least two data inputs, a scan input (scanin) and afunctional input (D_(in)), and two clock inputs, a scan clock input(sclk) and a functional clock input (fclk). Each functional latch 2004further includes at least two data outputs, namely, a scan output(scanout) and a functional output (D_(out)). To form a test scan chain2006, the scan input of a first functional latch 2004 and the scanoutput of a last functional latch 2004 are coupled to test portcontroller 2000, and the scan output of each functional latch 2004 inthe test scan chain 2006 (other than the last) is connected to the scaninput of a next functional latch 2004.

[0257] Each functional latch 2004 latches in the data bit present at itsscanin and latches out its former value at scanout in response to apulse of scan clock 2010 on sclk, and latches in the data bit present atD_(in), and latches out its former value in response to receipt of apulse of functional clock 2002 on fclk. Thus, by repeated pulsing ofscan clock 2010, the functional latches 2004 forming a test scan chain2006 transfer data bits in from and out to test port controller 2000 ina “bit-bucket brigade” fashion, thereby allowing test port controller2000 to read or write one or more functional latches 2004 in a test scanchain 2006.

[0258] SCOM chains 2008 are utilized to read and write functionallatches 2004 when functional clock 2002 is active and scan clock 2010 isinactive. Each SCOM chain 2008 includes multiple sequentially connectedSCOM cells 2012, the first and last of which are connected to test portcontroller 2000 to permit test port controller 2000 to scan data bitsinto and out of SCOM cells 2012. As depicted, in the exemplaryembodiment, each SCOM cell 2008 contains a functional latch 2004 forminga portion of an “SCOM register,” as well as a shadow latch 2014 forminga portion of a “shadow register”. It is preferred if all shadow latches2014, like functional latches 2004, also belong to a test scan chain2006.

[0259] As shown, each functional latch 2004 in each SCOM cell 2012 isconnected to an associated multiplexer 2020 having a scan input (scomin)coupled to the output of the corresponding shadow latch 2014 and a datainput (D_(in)) coupled by a hold path to the data output (D_(out)) ofthe associated functional latch 2004. Multiplexer 2020 selects the databit present at one of data input (D_(in)) and scomin as an input offunctional latch 2004 in response to select signal sel2. Functionallatch 2004 latches the selected data bit in response to functional clockfclk.

[0260] Shadow latch 2014 in each SCOM cell 2012 is similarly connectedto an associated multiplexer 2022 having a data input (D_(in)) coupledto the data output (D_(out)) of functional latch 2004, a hold inputcoupled by a hold path to the output of shadow latch 2014, and scaninput (scomin). In the first SCOM cell 2012, the scan input is connectedto test port controller 2000, and in the remaining SCOM cells 2012, thescan input is connected to the output of the shadow latch 2014 in thepreceding SCOM cell 2012. The output of the shadow register 2014 of thelast SCOM cell 2012 in each SCOM chain is connected to test portcontroller 2000. Multiplexer 2022 selects among the data bits present atits inputs as the input of the associated shadow latch 2014 in responseto select signal sell. Shadow latch 2014 latches the selected data bitin response to functional clock fclk.

[0261] The chain of shadow registers is used to read values from andwrite values to the associated SCOM registers. For example, to set anSCOM register, test port controller 2000 scans a new value into shadowlatches 2014 via the scomin inputs of multiplexers 2022 by assertingappropriate values of selects sel 1. Once all shadow latches 2014 havebeen loaded, test port controller 2000 controls select inputs sel2 tocause functional registers 2004 to load the values from shadow latches2014. To read a value from the SCOM registers, test port controller 2000drives sell to read the values out of the functional latches 2004 intothe shadow latches 2014 and then scans the values out of the shadowlatches 2014 by asserting appropriate values of selects sell.

[0262] In the exemplary embodiment, SCOM chains 2008 employ shadowlatches 2014 to read and write functional latches 2004 to avoiddisrupting the proper functional operation of integrated circuit chip1910, or even data processing system 1902. By loading all shadow latches2014 prior to updating any functional latches 2004, all functionallatches 2004 within a SCOM chain 2008 can be updated at once withoutdisrupting their values for multiple cycles of functional clock 2002. Itshould be understood that the particular implementation of SCOM chains2008 illustrated in FIG. 20 is not required to practice the presentinvention, and that other alternative designs may be employed, includingsome that do not include shadow latches 2014.

[0263] Thus, by loading the appropriate values into functional latches2004 and by appropriate control of functional clock 2002 and scan clock2010, each test port controller 2000 can initialize and configure itsintegrated circuit chip 1910 in a desired manner based upon inputs fromservice processor 1920 and/or workstation computer 1904.

[0264] In order to configure hardware functional latches 2004 in themanner described above, a HW configuration database 1932 that accountsfor the differences between simulation and hardware environments must begenerated. In general, the structure and contents of HW configurationdatabase 1932 reflect at least two central differences from theconfiguration database 814 for simulation described above.

[0265] The first difference is in the manner in which latches areaddressed in hardware. In particular, instead of utilizing a fullyqualified instantiation identifier for the configuration latch as insimulation, each hardware functional latch 2004 within a particularintegrated circuit 1910 is addressed and accessed for test scanning byan ordered pair consisting of a scan chain (or ring) identifierspecifying a particular test scan chain 2006 and an offset indicatingthe latch's bit position in the test scan chain 2006. Functional latches2004 within SCOM rings 2008 are similarly addressed and accessed forSCOM scanning using a similar ordered pair of (ring identifier, offset),specifying a particular SCOM chain 2008 and the offset of thecorresponding shadow latch 2014. Importantly, the SCOM ring identifierand offset for a particular functional latch 2004 do not have the samevalues as the corresponding test scan ring identifier and offset. Infact, in alternate SCOM implementations, different SCOM hardware may beused, and the offset can be expressed as a tuple: (ring ID, register,offset). It will therefore be appreciated that functional registers 2004may be addressed and accessed utilizing multiple access methods, each ofwhich may have its own addressing scheme, all of which will likelydiffer from that employed in simulation.

[0266] A second important difference between HW configuration database1932 and the configuration database 814 employed in simulation is theoverall database structure. As described above, configuration database814 is a monolithic database that may be utilized to represent anarbitrarily selected digital design of any size or complexity by nestingdesign entities hierarchically. A new configuration database 814 isgenerated by configuration compiler 808 for each different digitaldesign that is simulated. Although this approach is satisfactory in asimulation environment, the monolithic database structure employed insimulation does not correspond to the actual physical mechanismsutilized to access and set hardware latches in a hardware digitaldesign. Moreover, it is desirable in a laboratory environment to avoiddeveloping an entirely new system firmware 1930 and HW configurationdatabase 1932 for each different hardware permutation. For example, itis desirable to minimize development time and cost by reusing some orall of a particular HW configuration database 1932 and system firmware1930 to initialize and configure each server computer in a serverproduct line supporting between 8 and 32 processing units and 1 to 4different memory controllers.

[0267] Consequently, as described in detail below, HW configurationdatabase 1932 is preferably structured as a federation of smallerdatabases that each corresponds to a particular type (not instance) ofintegrated circuit chip present within the hardware digital design. Thisdatabase structure supports construction of a HW configuration database1932 for a hardware system of any desired size and complexity from thesame “building block” per-chip-type databases. Moreover, this databasestructure reflects the fact that hardware latches are accessed by systemfirmware 1930 on a per-chip basis.

[0268] Referring now to FIG. 21, there is depicted a high level flowdiagram of an exemplary process by which the simulation configurationdatabase 814 of each integrated circuit chip is transformed to obtain achip HW database utilized to construct a HW configuration database 1932suitable for laboratory testing and debugging and commercial deployment.The illustrated process may be implemented through the execution ofsoftware on data processing system 6 of FIG. 1.

[0269] The process begins with the execution of a scan chain detectiontool 2100. Scan chain detection tool 2100 processes the simulation model1400 of each integrated circuit chip 1910 within a target hardwaresystem, such as data processing system 1902, to produce a respectiveoutput file corresponding to each functional latch access path/methodfor latches within the integrated circuit chip 1910. For example, in theexemplary embodiment, scan chain detection tool 2100 generates a testscan definition file 2104 corresponding to test scanning and a SCOMdefinition file 2102 corresponding to SCOM scanning. Each of these files2102, 2104 provides, for latches within simulation model 1400, acorrespondence between the latch's scan ring identifier and offset (orother hardware address for the associated access method) and its fullyqualified latch instance name for simulation purposes.

[0270] The test scan definition file 2104 and SCOM definition file 2102and the simulation configuration database 814 for the integrated circuitchip are then processed by a database transformation tool 2106 togenerate a chip HW database 2108 that can be utilized as a buildingblock to obtain a HW configuration database 1932 for a hardware systemof any arbitrary system size and component list.

[0271] With reference now to FIG. 22A, there is illustrated a high levellogical flowchart of an exemplary process by which databasetransformation tool 2106 generates a chip HW database 2108 from thecorresponding simulation configuration database 814 for the integratedcircuit chip by reference to test scan definition file 2104 and SCOMdefinition file 2102. As illustrated, the process begins at block 2200and then proceeds to block 2201, which illustrates loading thesimulation configuration database 814 from non-volatile data storageinto volatile memory and augmenting its fields in the manner discussedabove with respect to FIG. 13 to obtain an expanded configurationdatabase 1404. Test scan definition file 2104 and SCOM definition file2102 are also loaded into volatile memory.

[0272] Next, at block 2202, a determination is made whether or not alllatch data structures 1204 referenced by latch pointer array 1210 havebeen processed. If so, the process terminates at block 2204. However, ifall latch data structures 1204 have not yet been processed, the processpasses from block 2202 to block 2206, which illustrates the selectionfor processing of the latch data structure 1204 pointed to by the nextlatch pointer 1254 in latch pointer array 1210. Next, at block 2208, thefully qualified latch name of the latch corresponding to the latch datastructure 1204 under consideration is formed by using the parent pointer1242 to access the contents of instance name field 1234 of the Dialinstance controlling the latch and appending those contents to thecontents of latch name field 1244.

[0273] Test scan definition file 2104 is then searched for this fullyqualified latch name, as depicted at block 2210. If the fully qualifiedlatch name is not found within test scan definition file 2104, an erroris flagged at block 2212 because, in the exemplary embodiment, allconfigurable latches must be scannable. Otherwise, databasetransformation tool 2106 calls the API routineadd_access_method(method_id, method_name) at block 2214 to augment latchdata structure 1204 to form a new latch data structure 2230. Themethod_id parameter of the API calls identifies a particular accessmethod (e.g., with a string or integer), and the method_name parameterspecifies a “name” utilized by the associated access method to access,in hardware, the latch corresponding to the new latch data structure2230. As illustrated in FIG. 22B, the new latch data structure 2230 iscreated at block 2214 by adding to latch data structure 1204 a method IDfield 2232 a specifying a method identifier of this access method (whichis “0” by convention) and a method name field 2234 a specifying a testscan ring identifier and offset value for the latch.

[0274] The process proceeds from block 2214 to block 2216, whichrepresents repeating the search for the fully qualified latch instancename performed at block 2210 using the definition file for the nextaccess method, in this case, SCOM definition file 2102. If no match forthe fully qualified latch instance name is found within SCOM definitionfile 2102, no error is logged because not all latches belong to SCOMchains, and the process simply passes to block 2220, which is describedbelow. If, on the other hand, a match is found, the add_access_method( )API routine is again called at block 2218 to augment latch datastructure 2230 with a method ID field 2232 n specifying the methodidentifier of this access method and a method name field 2234 nspecifying a SCOM scan ring identifier and offset value for the latch.

[0275] Finally, at block 2220, the API routine delete_latch_name( ) iscalled to delete latch name field 1244 from latch data structure 2230.Latch name field 1244 is no longer needed because a ring identifier andoffset pair uniquely identifies any latch within the integrated circuitchip 1910. The process then returns to block 2202, which has beendescribed.

[0276] The method of FIG. 22A thus alters the simulation configurationdatabase of each integrated circuit chip to include informationindicating the access methods available for each hardware functionallatch and the “method name” (i.e., identifier) of the latch for eachavailable access method. Although the illustrated process depicts themodification of a simulation configuration database to support twoparticular access methods, the illustrated method can be employed tohandle any number or types of access methods.

[0277] Once all of the simulation configuration databases for eachintegrated circuit in a system have been processed in the mannerillustrated in FIGS. 21 and 22A, the resulting chip hardware databases2108 can then be combined to form HW configuration database 1932illustrated in FIG. 19. In a preferred embodiment, HW configurationdatabase 1932 is constructed from chip HW databases 2108 by creating achip pointer data structure 2320 (FIG. 23B) that contains a respectivechip database pointer 2322 referencing the chip HW database 2108 of eachtype of chip in data processing system 1902. For example, if dataprocessing system 1902 includes 32 identical integrated circuitprocessor chips, chip pointer data structure 2320 will contain (inaddition to other chip database pointers 2322 corresponding to othertypes of integrated circuit chips) only one chip database pointer 2322to a single chip HW database 2108 describing the digital design embodiedby the 32 integrated circuit processor chips. This HW configurationdatabase 1932 is then stored in non-volatile storage, such asnon-volatile storage 1940 or flash ROM 1924, as shown in FIG. 19.

[0278] In order to configure a hardware digital design utilizing a HWconfiguration database 1932, the HW configuration database 1932 is firstloaded from non-volatile storage into volatile memory in accordance withthe exemplary process depicted in FIG. 23A. The process shown in FIG.23A may be performed, for example, in a laboratory environment byworkstation computer 1904 through the execution of system firmware 1930b by processing unit 1922 b. Similarly, when data processing system 1902is deployed commercially, service processor 1920 executes systemfirmware 1930 a according to the process of FIG. 23A to load HWconfiguration database 1932 a from flash ROM 1924 to volatile memory1928 a.

[0279] As illustrated, the process of FIG. 23A begins at block 2300 andthen proceeds to block 2302, which illustrates a determination of thetypes of integrated circuit chips and number of each type present withina target data processing system, such as data processing system 1902. Inan exemplary embodiment, the determination illustrated at block 2302 ismade by system firmware 1930, which consults a set of so-called VitalProduct Data (VPD) to determine which of the thousands of possiblemachine configuration is represented by data processing system 1902.

[0280] The process then proceeds to blocks 2306-2310, which collectivelyform a loop in which chip pointer data structure 2320 is walked toprocess the chip HW databases 2108 of the integrated circuit chipscomprising data processing system 1902. First, at block 2306 adetermination is made whether the chip HW database 2108 of each type ofintegrated circuit chip within data processing system 1902 has beenprocessed. If so, loading of HW configuration database 1932 intovolatile memory is complete, and the process terminates at block 2312.If, however, the chip HW database 2108 corresponding to each type ofintegrated circuit chip identified by the VPD has not been processed, anext chip HW database 2108 is loaded into volatile memory 1928 ofworkstation 1904 for processing at block 2308.

[0281] As shown in FIG. 23B, which depicts an in-memory view of HWconfiguration database 1932, loading of the chip HW database 2108creates in-memory data structures as described above, such as a Dialpointer array 1208, latch pointer array 1210, and an instance pointerarray 1226 within each DDDS 1200 (see FIG. 12). In addition, a latchvalue field 2324 and a latch set field 2326 are created within eachlatch data structure 2230, and a Dial set field 2328 is created withineach DIDS 1202. Each of these three fields is implemented as an array inwhich each entry corresponds to a particular instance of the integratedcircuit chip 1910 corresponding to the current chip HW database 2108.Finally, an empty chip mapping table 2325 is created.

[0282] Next at block 2310, a respective entry is added to chip mappingtable 2325 for each instance of the type of integrated circuit chipcorresponding to the current chip HW database 2108. This step ispreferably performed by system firmware 1930 via a call to a HWconfiguration API 1934 that accesses the VPD to determine how manyinstances of the type of integrated circuit chip corresponding to thecurrent chip HW database 2108 are contained in the present hardwaredigital design. By convention, the order of the entries within chipmapping table 2325 corresponds to the order of array entries in Dial setfield 2328, latch value field 2324 and latch set field 2326.

[0283] As shown in FIG. 23B, each entry within chip mapping table 2325associates two firmware-supplied values: (1) a chip instance name, whichis a string like that identifying the design entity representing theintegrated circuit chip instance in the simulation model of dataprocessing system 1902 (e.g., a.b.c.d) and (2) a chip ID specifying anidentifier of the test access port 1914 by which service processor 1920communicates with that integrated circuit chip instance. Thus, any latchin data processing system 1902 can now be readily addressed by the tuple(chip ID, scan ring, offset), which is associated by chip mapping table2325 with the chip-identifying portion of the fully qualified latch nameemployed by HW configuration APIs 1934. Thereafter, the process returnsto block 2306, which has been described.

[0284] The process depicted in FIG. 23A thus permits a single HWconfiguration database 1932 to be utilized to build an in-memory HWconfiguration database for a data processing system of any arbitrarysize or configuration, eliminating the need to develop and store aseparate monolithic configuration database for each possible system sizeand configuration.

[0285] With HW configuration database 1932 loaded into a volatile memory1928, system firmware 1930 can then be executed by processing unit 1922a of service processor 1920 or processing unit 1922 b of workstationcomputer 1904 to call HW configuration APIs 1934 to read or set aconfiguration of one or more integrated circuit chips 1910 of dataprocessing system 1902. As in simulation, HW configuration APIs 1934preferably include separate API routines to read Dials and Dial groupsin interactive and batch modes. Also like simulation, the API calls bysystem firmware 1930 specify an instance qualifier (e.g., a.b.c.d ora.b.c.[X]) and a dialname qualifier (e.g., Entity.dialname) for eachDial or Dial group instance to be set or read.

[0286] Because multiple access methods can be utilized to set or read aDial or Dial group, API calls to set or read a Dial or Dial groupinstance preferably include an additional parameter, access_method. In apreferred embodiment, the access_method parameter can take the valuesSCAN, which indicates test scanning, SCOM, which indicates SCOMscanning, and AUTO, which indicates that the HW configuration API 1934is to select the access method. In response to an AUTO value for theaccess_method parameter, a HW configuration API 1934 selects an accessmethod based upon the supported access method(s) indicated by the methodID(s) 2232 in the latch data structure(s) 2230 targeted by the API calland upon which of functional clock 2002 and scan clock 2010 is running.As described above, SCOM scanning is only available when functionalclock 2002 is running, and test scanning is only available when scanclock 2010 is running.

[0287] Before any HW configuration API 1934 can set or read a Dial orDial group instance, the HW configuration API 1934 must first determinewhich Dial or Dial group instances are identified by the instancequalifier and dialname qualifier specified in the API call. Referringnow to FIG. 24 there is depicted a high level logical flowchart of anexemplary process by which a HW configuration API 1934 locatesparticular Dial or Dial group instances in HW configuration database1932 in accordance with the present invention. The illustrated processis analogous to the process depicted in FIG. 15 and described above.

[0288] As shown, the process begins at block 2400 in response to receiptby a HW configuration API 1934 of an API call from firmware 1930 havingas an argument an instance qualifier and a dialname qualifier of one ormore Dial or Dial group instances, as discussed above. In response tothe API call, the configuration API 1934 enters HW configurationdatabase 1932 at chip pointer array 2320 and, as depicted at block 2402,enters a loop in which chip database pointers 2322 are processed untilone or more matching Dial instances are located within a particular chipHW database 2108 or until all chip database pointers 2322 have beenprocessed. In response to a determination at block 2402 that all chipdatabase pointers 2322 have been processed without locating any matchingDial instances, the process terminates with an error at block 2403.However, if fewer than all of chip database pointers 2322 have beenprocessed, the next chip database pointer 2322 is selected from chippointer data structure 2320 for processing, as depicted at block 2406.The selected chip database pointer 2322 is utilized to locate theassociated chip HW database 2108.

[0289] Following block 2406, the process proceeds to block 2408 andfollowing blocks, which represent a processing loop in which each Dialpointer 1252 in the Dial pointer array 1208 of the current chip HWdatabase 2108 is processed until a particular Dial matching the API callis located or until all Dial pointers 1252 (FIG. 12) have been processedwithout finding any matching Dial instances. In response to adetermination at block 2408 that all Dial pointers 1252 have beenprocessed without locating any matching Dial entity, the process returnsfrom block 2408 to block 2402 in order to process the next chip databasepointer 2322 in chip pointer array 2320 (i.e., to process the next chipHW database 2108). If, on the other hand, a determination is made atblock 2408 that not all Dial pointers 1252 within Dial pointer array1208 have been processed, the process proceeds to block 2410, whichillustrates the selection from Dial pointer array 1208 of the next Dialpointer 1252 for processing.

[0290] Next, a determination is made at block 2412 of whether or not theDDDS 1200 referenced by the current Dial pointer 1252 has a name field1222 that exactly matches the specified dialname qualifier. With respectto name fields 1222, two implementations are possible. First, reuse ofDial names can be prohibited so that every Dial name is uniquethroughout not only its own integrated circuit chip, but also throughoutthe entire system (e.g., data processing system 1902). A second, lessrestrictive approach is to require each Dial name to be unique onlywithin its integrated circuit chip 1910 and to permit multiple uses of aDial name in different integrated circuits. In order to support thesecond approach, name field 1222 takes the form “chiptype.Dial name”,where “chiptype” is a unique string identifying the type of integratedcircuit chip 1910, thus disambiguating identical Dial names applied toDial entities instantiated in different integrated circuit chips 1910.

[0291] In response to a determination at block 2412 that name field 1222does not match the specified dialname qualifier, the process returns toblock 2408 for processing of the next Dial pointer 1252, if any, asdescribed above. If, however, a match is found, the process then entersa processing loop comprising blocks 2420-2434 in which the Dialinstances represented by individual DIDS 1202 are examined for a matchwith the API call's instance qualifier utilizing the instance pointers1228 in the instance pointer array 1226 of the DDDS 1200 of the matchingDial entity. In this processing loop, a determination is first made atblock 2420 of whether or not all instance pointers 1228 within thecurrent DDDS 1200 have been processed. If so, a further determination ismade at block 2434 of whether or not at least one matching instance ofthe Dial entity corresponding to the current DDDS 1200 was found. Thisdetermination is made because the construction of HW configurationdatabase 1932 ensures that at most one matching Dial (not Dial instance)in only one chip HW database 2108 will match the instance qualifier anddialname qualifier specified in the API call. Consequently, if amatching instance is found for a particular Dial entity, no further Dialentities or chip HW databases 2108 need be searched. Accordingly, if adetermination that at least one matching Dial instance has been foundfor the Dial entity corresponding to the current DDDS 1200, the processpasses from block 2434 to block 2438 and terminates. If, however, adetermination is made at block 2434 that no match was found, the processpasses through page connector A and terminates with an error at block2403.

[0292] Returning to block 2420, in response to a determination that allinstance pointers 1228 of the current DDDS 1200 have not been processed,the process proceeds to block 2422, which illustrates the selection ofthe next instance pointer 1228 and its associated DIDS 1202 forprocessing. A determination is then made at block 2424 whether the DIDS1202 has been processed with respect to the Dial instance in each of theintegrated circuit chips 1910 corresponding to the current chip HWdatabase 2108 by processing each entry in chip mapping table 2326. Ifso, the process passes to block 2436, which is described below. Ifprocessing of all entries in chip mapping table 2325 has not beencompleted, the process proceeds to block 2426. Block 2426 depictsforming the next fully qualified Dial instance name to be matchedagainst the instance qualifier specified in the API call by prependingthe chip instance name in the next entry of chip mapping table 2325 tothe instance name field 1234 of the current DIDS 1202. This fullyqualified Dial instance name is then compared to the instance qualifierat block 2430. If they do not match, the process returns to block 2424,which has been described. If they do match, a temporary result pointerand associated chip vector are created at block 2432, if they do notalready exist. The temporary result pointer points to the current DIDS1202 to identify the corresponding Dial instance as matching theinstance qualifier specified in the access request. An entry is alsoplaced in the associated chip vector to indicate the particularintegrated circuit chip instance 1910 in which this matching Dialinstance is located. In an exemplary embodiment, the chip vector maysimply comprise a same number of bits as there are entries in chipmapping table 2325, with a bit value of “1” indicating that thecorresponding integrated circuit chip instance 1910 contains a matchingDial instance. Following block 2432, the process returns to block 2424.

[0293] The processing loop represented by blocks 2424-2432 is repeatedfor each entry in chip mapping table 2325. After all entries have beenprocessed, the process passes from block 2424 to block 2436, whichdepicts a determination of whether the dialname qualifier was specifiedutilizing non-bracketed syntax and, if so, whether or not a match wasfound for the specified dialname qualifier among the Dial instancesrepresented by the current DIDS 1202. If the determination is negative,it is possible that additional matching Dial instances associated withanother DIDS 1202 may exist. Accordingly, the process returns to block2420 to process the next instance pointer 1228 of the current DDDS 1200.If, however, the determination at block 2436 is positive, it is knownthat all matching Dial instances have been located and identified withtemporary result pointers and associated chip vectors. The processtherefore terminates at block 2438.

[0294] After the Dial or Dial group instances specified by the instancequalifier and dialname qualifier have been determined by the processshown in FIG. 24, the Dial or Dial group instance(s) are set or read inmuch the same fashion as described above with respect to FIGS. 16A(reading a Dial instance in interactive mode), 16B (reading a Dial groupinstance in interactive mode), 17A (setting a Dial instance ininteractive mode), 17B (setting a Dial group instance in interactivemode) and 18 (setting a Dial instance or Dial group instance in batchmode). A few differences are required, however, to account for the useof a single chip HW database 2108 to represent possibly multipleintegrated circuit chips 1910 and for the availability of multipledifferent access methods to access integrated circuit chips 1910. Thesedifferences are detailed below.

[0295] When reading Dial instances or Dial group instances, latch valuesare verified by propagating the latch values “up” the Dial trees in theconfiguration database, as described with reference to block 1624 ofFIG. 16A. Conversely, when setting Dial instances or Dial groupinstances, Dial values are propagated “down” the Dial trees in theconfiguration database to the latch data structures, as described abovewith reference to block 1714 of FIG. 17A. In simulation, only one latchvalue at a time is propagated “down” to or “up” from any one latch datastructure 1204. However, because HW configuration database 1932represents multiple integrated circuit chips 1910 of the same type witha single chip HW database 2108, reading or setting a Dial or Dial groupinstance by reference to a chip HW database 2108 representing multiplephysical integrated circuit chips 1910 entails propagating multipleelements of a value set up or down the Dial tree in parallel, where eachelement of the value set is the value for a particular chip instanceidentified by the temporary result pointer and chip vector constructedin FIG. 24.

[0296] Similarly, in simulation, each of Dial set field 1239, latchvalue field 1246, and latch set field 1248 within configuration database1404 contains only a single value. In contrast, the corresponding Dialset fields 2328, latch value fields 2324, and latch set fields 2326within HW configuration database 1932 are implemented as arrays in whicheach element corresponds to an individual Dial or latch instance for aparticular integrated circuit chip 1910. Accordingly, when Dial, Dialgroup and latch instances are set, the elements within Dial set fields2328, latch value fields 2324, and latch set fields 2326 correspondingto the set instances are updated in accordance with the temporary resultpointer and chip vector constructed in FIG. 24.

[0297] Because laboratory or commercial use of HW configuration database1932 entails accessing physical hardware (i.e., integrated circuit chips1910) utilizing multiple possible access methods, three additionaldifferences from a simulation environment are noted in a preferredembodiment. First, a set or read operation requested in an API callpreferably fails (i.e., is not performed) if a HW configuration API 1934determines that the access method indicated by the access_methodparameter contained within the API call is not available for any of theDial instances identified by the temporary result pointer(s) and chipvector(s) obtained by the process of FIG. 24. As described above, theaccess method(s) by which each latch can be set or read is indicated bythe method ID field(s) 2232 of each latch data structure 2230.

[0298] Second, a set or read operation requested in an API callpreferably succeeds only if a HW configuration API 1934 determines thatthe functional clock 2002 and scan clock 2010 within each integratedcircuit chip 1910 targeted by the API call are in the appropriate statesfor the access_method parameter contained within the API call. That is,if the access_method parameter has the value SCAN, the functional clock2002 must be disabled, and the scan clock 2010 must be enabled.Conversely, if the access_method parameter has the value SCOM, thefunctional clock 2002 must be enabled, and the scan clock 2010 must bedisabled. If the access_method parameter has the value AUTO, thefunctional clock 2002 and scan clock 2010 of each integrated circuitchip 1910 containing a latch targeted by the API call must be in statesthat permit at least one access method of each such latch to beemployed.

[0299] Third, the HW configuration APIs 1934 utilized to read and sethardware latches, read_latch( ) and write_latch( ), preferably minimizescan accesses to integrated circuit chips 1910 by implementing shadowscan chain buffers in volatile memory 1928 and by accessing such scanchain buffers when possible in lieu of scanning a scan chain in anintegrated circuit chip 1910. For example, the read_latch( ) HWconfiguration API 1934, which corresponds to the GETFAC( ) API 1412employed in simulation, preferably obtains latch value(s) from thecorresponding shadow scan chain buffers in volatile memory 1928 in casesin which the latch value(s) in volatile memory 1928 are known to becurrent. In addition, multiple updates to latch values via thewrite_latch( ) API, which corresponds to the PUTFAC( ) API 1414 utilizedin simulation, are preferably buffered in the shadow scan chain buffersin volatile memory 1928. In this manner, multiple writes to latches in aparticular scan chain of an integrated circuit chip 1910 can be made byscanning the particular scan chain only once.

[0300] HW configuration APIs 1934 preferably further include acheck_chip( ) API similar to the check_model( ) API available insimulation. When called, the check_chip( ) API utilizes top-levelpointer array 1206 within a specified chip HW database 2108 to verifythat each top-level CDial and LDial instance within the chip HW database2108 is set to one of its legal values. Specifically, the check_chip( )API propagates the underlying hardware latch values up the Dial tree ofeach top-level CDial and LDial instance by reference to its mappingtable 1224 and the mapping table(s) 1224 of any lower-level Dialinstance(s) in its Dial tree. Any top-level LDial or CDial instance setto an illegal value is returned by the check_chip( ) API.

[0301] Referring again to FIG. 19, in many commercial embodiments ofdata processing system 1902, the storage capacity of non-volatilestorage (e.g., flash ROM 1924) within service processor 1920 issignificantly less than that of the non-volatile storage 1940 (e.g.,hard disk storage) of the workstation computer 1904 utilized to storesystem firmware 1930 b and HW configuration database 1932 b.Accordingly, it is usually desirable or necessary to reduce the size ofthe system firmware 1930 b and HW configuration database 1932 bdeveloped in a laboratory hardware testing environment to obtain thesystem firmware 1930 a and HW configuration database 1932 a commerciallydeployed within flash ROM 1924 (or other non-volatile storage) of dataprocessing system 1902.

[0302] Accordingly, with reference now to FIG. 25, there is illustrateda high level logical flow diagram of an exemplary process by which eachchip HW database 2108 developed during laboratory development andtesting of system firmware 1930 can be compressed through theelimination of unnecessary information in order to obtain a HWconfiguration database 1932 a suitable for commercial deployment. Theprocess begins by generating Dial usage information 2500 indicatingwhich Dial instances within a particular type of integrated circuit chip1910 have been set and/or read and the values to which Dial instanceshave been set.

[0303] The determination of which Dial instances are set or read and thevalues to which Dial instances have been set can be accomplished in anumber of ways well known to those skilled in the art. For example,system firmware 1930 can be manually examined to generate Dial usageinformation 2500. Alternatively, system firmware 1930 can be executed ina number of possible machine configurations that cover all the settingsto which Dial instances in the type of integrated circuit chip 1910under consideration may be set. The Dial instances that are set and readand the values to which Dial instances are set can then be logged asDial usage information 2500.

[0304] In a preferred embodiment, all that is recorded within Dial usageinformation 2500 for IDial instances is whether or not the IDialinstance is set or read. No IDial instance values are recorded becauseit is assumed, for purposes of generating Dial usage information 2500,that if an IDial instance is set, all of its possible values may beutilized. There are, however, particular IDial instances that developersknow will only be set to a single value. To permit the elimination ofthese IDials from HW configuration database 1932 a, these IDials andtheir associated values can optionally be specified by a developerwithin an override file 2502. Override file 2502 may also contain a listof Dial instances, if any, that the developer desires to explicitlypreserve within HW configuration database 1932 a, regardless of whetheror not the Dial instance is read or set.

[0305] Thus, for each chip HW database 2108, Dial usage information 2500and override file 2502 are preferably obtained that collectively containat least the following information:

[0306] 1) a list of all the top-level non-IDial instances set within anyof the instances of the integrated circuit chip in any configuration anda list of any top-level IDials set to any value within any of theinstances of the integrated circuit chip in any configuration;

[0307] 2) a list of all the values of each non-IDial instance that isset;

[0308] 3) a separate list of IDials set to a single value; and

[0309] 4) a list of all Dial instances that are read.

[0310] As further illustrated in FIG. 25, this information is thenutilized by a software compression tool 2504 (e.g., executed byworkstation computer 1904) to eliminate unnecessary information from theassociated chip HW database 2108. Compression tool 2504 produces twooutputs: (1) a compressed chip HW database 2506 forming a portion of HWconfiguration database 1932 a and (2) initial scan chain images 2508utilized to develop the scan chain images to which test scan chains 2006in the integrated circuit chip 1910 are initialized during execution ofsystem firmware 1930 a. As indicated, these initial scan chain images2508 may be non-destructively combined with additional scan chain inputs2510 to obtain final scan chain images 2512.

[0311] Referring now to FIGS. 26A-26C, there is depicted a high levellogical flowchart of a method by which compression tool 2504 compressesa chip HW database 2108 in accordance with the present invention. Asdescribed in detail below, the illustrated method implements at leastthree size optimizations.

[0312] First, information related to a Dial instance may be eliminatedfrom a chip HW database 2108 if the Dial instance will never be set orread by system firmware 1930 a. Because such Dial instances will neverbe set or read by system firmware 1930 a, the DIDS 1202 corresponding tosuch Dial instances will never be referenced within HW configurationdatabase 1932 a and may accordingly be removed. It is important to notethat the fact that system firmware 1930 a does not set or read a Dialinstance does not necessarily mean that the Dial instance is not set orread during simulation or laboratory debugging. Many Dial instances(e.g. mode Switches) are never set by system firmware 1930 a, but aretested during simulation to ensure that the mode Switches work properlyif needed by a later firmware revision.

[0313] A second reason that information related to a Dial instance maybe unnecessary is if the Dial instance is set to only one value in allconfigurations. In this case, the DIDS 1202 corresponding to the Dialinstance can be removed from chip HW database 2108 because the effectsof setting the Dial instance can instead be achieved by setting thefinal scan chain image 2512 scanned into an integrated circuit chip 1910with the latch value(s) that would be obtained by setting the Dialinstance. The code within system firmware 1930 b that sets the Dialinstance can likewise be eliminated to reduce the size of systemfirmware 1930 a ultimately obtained from laboratory testing anddebugging.

[0314] Third, mapping tables 1224 in DDDSs 1200 may be optimized byeliminating values to which Dials are never set by system firmware 1930a.

[0315] In making the foregoing optimizations, special consideration isgiven to Dial instances that are read. In general, when a Dial instanceis read, it is assumed in the exemplary compression methodologydescribed below that the entire Dial tree containing the Dial instancethat is read must be preserved within its chip HW database. In addition,it is assumed that all entries within the mapping tables of Dials inDial trees containing Dial instances that are read must be preservedbecause, in commercial deployment, the hardware may set the underlyinglatches to values other than those read by system firmware.Consequently, it cannot be determined a priori which mapping tableentries will be required to read a Dial instance. Although theseassumptions limit compression, they ensure that each Dial instance thatis read can be easily accessed, regardless of whether or not the Dialinstance is a top-level Dial instance or a lower-level Dial instance.

[0316] Referring first to FIG. 26A, the process begins at block 2600 andthen proceeds to block 2602, which illustrates compression tool 2504loading a chip HW database 2108 into volatile memory 1928 b and creatingin-memory data structures 1208, 1210 and 2325, as described above. Inaddition, as depicted at block 2604, compression tool 2504 creates, inassociation with each DIDS 1202, some additional temporary fields inmemory used only by compression tool 2506. These temporary fieldsinclude a Dial Instance Value Structure (DIVS) for storing the values,if any, to which the associated Dial instance is set within Dial usageinformation 2500. For IDial instances, the DIVS is handled specially. Inparticular, the DIVS will either be empty, contain a token indicatingthe IDial instance is set, or, for top-level IDial instances only,contain the single value to which the IDial instance is set, ifapplicable. The temporary fields created for each DIDS 1202 at block2604 also include a Dial Instance Preserve Field (DIPF), which is set toTRUE if the associated DIDS should be preserved (i.e., not deleted fromthe compressed chip HW database) and is set to FALSE otherwise. The DIPFof each DIDS 1202, if any, explicitly listed in override file 2502 as aDIDS to be preserved is initialized to TRUE, and all other DIPFs areinitialized to FALSE.

[0317] The process then proceeds from block 2604 to block 2606, whichillustrates compression tool 2504 entering a loop in which eachtop-level pointer 1250 in top-level pointer array 1206 is processed toenter relevant information from Dial usage information 2500 in the DIPFand DIVS of each DIDS 1202. If all top-level pointers 1250 have beenprocessed, the processes passes through page connector B to FIG. 26B,which is described below. If, however, all top-level pointers 1250 havenot yet been processed, the next top-level pointer 1250 within top-levelpointer array 1206 is selected for processing at block 2608.

[0318] The process then passes from block 2608 to blocks 2610 and 2612.Block 2610 illustrates compression tool 2504 processing each non-IDialin the Dial tree headed by the Dial instance corresponding to the DIDS1202 referenced by the current top-level pointer 1250. Compression tool2504 adds to the DIVS of each such DIDS 1202 the values for thecorresponding Dial instance contained within the Dial usage information2500. In addition, as shown at block 2612, compression tool 2504processes each IDial within the Dial tree headed by the Dial instancecorresponding to the DIDS 1202 referenced by the current top-levelpointer 1250. For each such IDial, compression tool 2504 adds a settoken to the DIVS if Dial usage information 2500 indicates that theIDial has been set.

[0319] Next, at block 2614, compression tool 2504 sets the DIPF of everyDIDS 1202 in the Dial tree headed by the Dial instance corresponding tothe DIDS 1202 referenced by the current top-level pointer 1250 if Dialusage information 2500 indicates that any Dial in the Dial tree wasread. In other words, each DIPF in the Dial tree is set to TRUE if anyDial instance in the Dial tree is read. The process then proceeds toblock 2616, which illustrates compression tool 2504 examining eachtop-level IDial, if any, corresponding to the DIDS 1202 referenced bythe current top-level pointer 1250 to determine whether override file2502 indicates that the IDial is set to only a single value. If so,compression tool 2504 adds to the DIVS of those top-level IDials thevalue contained within override file 2502 and removes a set token, ifpresent.

[0320] Thereafter, the process returns to block 2606, which illustratesthe continuation of the processing loop until all top-level pointers1250 within top-level pointer array 1206 have been processed. Once alltop-level pointers 1250 have been processed, the process passes throughpage connector B to FIG. 26B.

[0321] With reference now to FIG. 26B, the process proceeds from pageconnector B to block 2620, which illustrates a second processing loop inwhich each top-level pointer 1250 within top-level pointer array 1206 isprocessed. If a determination is made at block 2620 that all top-levelpointers 1250 within top-level pointer array 1206 have been processed inthe current processing loop, the process passes through page connector Cand continues in FIG. 26C. Otherwise, the process proceeds to block2622, which depicts the selection of the next top-level pointer 1250within top-level pointer array 1206 for processing.

[0322] Following block 2622, the DIVS and DIPF associated with the DIDS1202 referenced by the current top-level pointer 1250 are examined forone of three conditions respectively represented by decision blocks2624, 2630, and 2640. If a determination is made at block 2624 that theDIPF has a value of TRUE or if type field 1220 in the associated DDDS1200 indicates that the DIDS 1202 corresponds to a Dial group, theprocess simply returns from block 2624 to block 2620 for processing ofthe next top-level pointer 1250, if any.

[0323] If, however, a determination is made at block 2630 that the DIPFassociated with the DIDS 1202 referenced by the current top-levelpointer 1250 has a value of FALSE and the associated DIVS is empty, thencompression tool 2504 can remove the DIDS 1202 from chip HW database2108 because none of the corresponding Dial instances is set or read.Accordingly, as illustrated at block 2632, compression tool 2504 deletesthe DIDS 1202 from chip HW database 2108, as well as each lower-levelDIDS 1202, if any, in the Dial treeheaded by the deleted top-level DIDS1202. In addition, compression tool 2504 deletes the associatedtop-level pointer 1250 from top-level pointer array 1206, and sets theinstance pointer 1228 pointing to each deleted DIDS 1202 to NULL. Adetermination is then made at block 2634 of whether or not the parentpointer 1233 of the deleted DIDS 1202 was set to NULL. If so, theprocess returns to block 2620, which has been described. If, on theother hand, the parent pointer was not NULL, then the top-level Dialinstance(s) corresponding to the deleted DIDS 1202 belonged to Dialgroup instance(s). Because the top-level Dial instance(s) were never setor read, each such top-level Dial instance may be safely removed fromits respective Dial group instance. Accordingly, as shown at block 2636,compression tool 2504 deletes from the DIDS 1202 corresponding to theDial group instance(s) the output pointer 1238 to the deleted DIDS 1202of the top-level Dial instance. If the deletion of the output pointer1238 from the DIDS 1202 of the Dial group instances removes the lastmember of the Dial group, the DIDS 1202 corresponding to the Dial groupinstance(s) is also deleted from chip HW database 2108. This processcontinues, collapsing hierarchical levels of Dial groups, if possible.Following block 2636, the process returns to block 2620, which has beendescribed.

[0324] Returning to block 2640, compression tool 2504 determines whetherthe DIPF associated with the DIDS 1202 referenced by the currenttop-level pointer 1250 has a value of FALSE and the associated DIVScontains a single value. If not, the process returns to block 2620,which has been described. If so, a further determination is made atblock 2642 by reference to parent field 1232 of the DIDS 1202 of whetherthe Dial instance belongs to a Dial group. If so, the process preferablyreturns to block 2620 without further processing, signifying that theDIDS 1202 will be preserved. The DIDS 1202 is preferably preservedbecause operations setting a Dial group are atomic and will fail if aremoved Dial instance is referenced in the set_Dial_group( ) API call.In response to a determination at block 2642 that the Dial instancecorresponding to the DIDS 1202 referenced by the top-level pointer 1250does not belong to a Dial group, the process proceeds to block 2644.

[0325] Block 2644 illustrates propagating the single Dial valuecontained in the DIVS down the Dial tree by reference to mapping tables1224 (if necessary) in order to determine the latch values of thelatches terminating the Dial tree. The latch values determined at block2644 are then placed within initial scan chain images 2508 in scan chainlocations determined by reference to chip mapping table 2325, asillustrated at block 2646. Therefore, as shown as block 2648, the DIDS1202 referenced by the current top-level pointer 1250, its lower-levelDial tree, and top-level pointer 1250 itself are all removed from thechip HW database 2108, as described above with respect to block 2632. Inaddition, the set_Dial( ) API call utilized to set the top-level Dialinstances corresponding to the deleted DIDS 1202 is removed (typicallyby a human programmer) from system firmware 1930 b, as shown at block2650. Thereafter, the process returns to block 2620, which has beendescribed.

[0326] Referring now to FIG. 26C, processing begins at page connector Cand proceeds to block 2660, which illustrates a processing loop in whichall Dial pointers 1252 within Dial pointer array 1208 are processed toeliminate from chip HW database 2108 any unnecessary DDDSs 1200 and anyunnecessary entries within mapping tables 1224. After all Dial pointers1252 within Dial pointer array 1208 have been processed, the processpasses to block 2690, which is described below. If, however, less thanall Dial pointers 1252 have been processed, the process proceeds fromblock 2660 to block 2662, which illustrates selection of the next Dialpointer 1252 for processing.

[0327] Following selection of a next Dial pointer 1252, compression tool2504 determines at block 2664 whether all instance pointers 1228 withininstance pointer array 1226 of the DDDS 1200 referenced by the currentDial pointer 1252 are NULL. If so, the entire DDDS 1200 is unnecessaryand is removed from the chip HW database 2108, as shown at block 2666.Following block 2666, the process returns to block 2660, which has beendescribed.

[0328] In response to a determination at block 2664 that all instancepointers 1228 within the DDDS 1200 referenced by the Dial pointer 1252are not NULL, a further determination is made at block 2670 of whetheror not type field 1220 indicates that DDDS 1200 defines a IDial. If so,no optimization to mapping table 1224 is possible, and the processreturns to block 2660. If compression tool 2504 determines that block2670 that the DDDS referenced by the current Dial pointer 1252 does notdefine an IDial, the process proceeds to block 2672. Block 2672 depictsa determination of whether or not any DIPF associated with any DIDS 1202referenced by an instance pointer 1228 has a value of TRUE. If so, thiscondition indicates that at least one Dial instance of the Dial definedby DDDS 1200 has been read and therefore requires a full mapping table1224. Accordingly, the process returns to block 2660 without performingany optimization to mapping table 1224.

[0329] If, however, compression tool 2504 determines at block 2672 thatall DIPFs associated with DIDSs 1202 referenced by instance pointers1228 have a value of FALSE, the process proceeds from 2672 to theprocessing loop illustrated at blocks 2674,2676, and 2678. Thisprocessing loop represents compression tool 2504 processing eachinstance pointer 1228 within the instance pointer array 1226 of the DDDS1200 referenced by the current Dial pointer 1252 in order to build aDial value set containing all values to which the Dial instancescorresponding to the DIDSs 1202 were set by system firmware 1930. Asindicated at block 2678, the Dial values are obtained from the DIVSassociated with each DIDS 1202. After the Dial value set has been builtthrough processing each instance pointer 1228, the process passes fromblock 2674 to block 2680. Block 2680 illustrates compression tool 2504removing each entry in mapping table 1224 of the DDDS 1200 referenced bythe current Dial pointer 1252 whose Dial input value is not found withinthe Dial value set. This process continues down the Dial tree,eliminating mapping table entries that are not utilized to generate theDial value set. Thus, mapping tables 1224 of individual Dials areoptimized by the removal of unneeded entries. Thereafter, the processreturns to block 2660.

[0330] In response to a determination at block 2660 that all Dialpointers 1252 within Dial pointer array 1206 have been processed,compression tool 2504 performs a last compression at block 2690 byreplacing common portions of instance names within instance name fields1234 with pointers to a “dictionary” providing the full instance nameportions. This compression technique, which is well known to thoseskilled in the art, replaces instance names (or portions thereof) withpointers, which are typically significantly shorter than the instancename or instance name portions they replace. These pointers can then bereplaced within instance name fields 1234 as a step in the process inwhich HW configuration database 1932 a is loaded into volatile memory1928 a of service processor 1920. Following block 2690, compression tool2504 terminates processing at block 2692.

[0331] After all of the chip HW databases 2108 have been compressed bycompression tool 2504 in accordance with the method depicted in FIGS.26A-26C, the compressed chip HW databases 2108 can then be utilized toconstruct hardware configuration database 1932 a stored within flash ROM1924 by simply constructing a chip pointer data structure 2320. Itshould be noted that the compression methodology implemented bycompression tool 2504 is not exclusive. HW configuration APIs 1934 bpreferably include a suite of APIs that permit a developer to removeindividual DIDSs 1202, remove an entry in a mapping table 1224, andperform other optimizations similar to those illustrated in FIGS.26A-26C.

[0332] In the embodiments of the present invention described above, ithas been assumed that each Dial (i.e., LDial or IDial) that is logicallycoupled to a simulation configuration latch or hardware latch can setthe value contained in the simulation configuration latch or hardwarelatch. In practice, however, it is often desirable to be able to readsuch latches without permitting system firmware or a simulator to set(or alter) the latch values.

[0333] In view of the foregoing, a preferred embodiment of the presentinvention supports an additional class of configuration entitiesreferred to herein as read-only Dials or RDials. There is preferably aread-only configuration entity corresponding to each type of Dial andDial group described above, that is, a read-only LDial, CDial, IDial andDial group. For ease of understanding, each read-only configurationentity is referred to herein by the Dial or Dial group type name (e.g.,LDial, CDial, IDial and Dial group) preceded by an “R” designating theconfiguration entity as read-only (e.g., RLDial, RCDial, RIDial andRDial group).

[0334] RDials and RDial groups are subject to a number of rule sets.First, RDials and RDial groups are read-only and, by definition, cannotbe set by a simulator or system firmware. Consequently, RDials and RDialgroups cannot be assigned default values.

[0335] Second, the syntax defining an RDial or RDial group within aconfiguration specification statement is preferably the same as thatdescribed above for the corresponding non-read-only configurationentity, except that the keyword defining the configuration entity ispreceded by an “R”. For example, an exemplary configurationspecification statement for an RLDial can be given as follows: RLDialstate_machine (state_vector(0..1)        ) =        {idle =>0b00;       start =>0b01;        wait =>0b10;        end =>0b11        };

[0336] The exemplary configuration specification statement given abovebegins with the keyword “RLDial,” which specifies that the type of RDialbeing declared is an RLDial, and the RDial name, which in this case is“state_machine.” Next, the configuration specification statementenumerates the signal name(s) whose states are read by the RLDial.Following the enumeration of the signal identifiers, the configurationspecification statement includes a mapping table listing the permittedenumerated “input” values (or settings) of the RLDial and thecorresponding signal (i.e., “output”) values for each enumerated inputvalue. It should again be noted that the signal states specified for allenumerated values are unique, and collectively represent the only legalpatterns for the signal states.

[0337] Third, RDials have a different set of rules regardinginterconnection with Dials and RDials and grouping of Dials and/orRDials to form RDial groups. These rules are set forth in detail belowwith reference to FIG. 27, which is a graphical representation of aportion of an exemplary configuration database 2700 including Dials andRDials having specified logical connections to latches 2760-2778 of asimulation model or hardware system.

[0338] As an initial matter, RDials are subject to similar restrictionson interconnection to other RDials and latches as set forth above withrespect to the corresponding Dials. That is, in a preferred embodiment,an RIDial or an RLDial, but not an RCDial, can have its output directlycoupled to a latch, and an RCDial, but not an RIDial or RLDial, can haveits output connected to the input of a lower level RDial. Thus, forexample, RCDial 2740 has an output connected to the input of RCDial2742, which in turn has two outputs respectively connected to the inputsof RLDial 2744 and RIDial 2746. RLDial 2744 and RIDial 2746 have outputsconnected to latches 2770 and 2772, respectively.

[0339] In addition, an RCDial can have its output connected to the inputof any type of Dial, but no Dial is permitted to have its outputconnected to the input of any RDial. For example, RCDial 2740 has anoutput coupled to the input of CDial 2724. Although not explicitlyillustrated in FIG. 27, it should be noted that an RDial may haveoutputs connected to the inputs of RDials and/or Dials at multipledifferent levels of the same subtree.

[0340] To prevent conflicting settings, the Dials and Dial groupsdefined hereinabove permit each latch, Dial, and Dial group to have atmost one Dial or Dial group as a parent hierarchically “above” it in ann-way Dial tree. For example, each of CDial 2722 and CDial 2724 has onlyone Dial parent (i.e., CDial 2720), each of LDial 2726 and IDial 2728has only one Dial parent (i.e., CDial 2722), and each of LDial 2730 andIDial 2732 has only one Dial parent (i.e., CDial 2724). However, becauseRDials and RDial groups are, by definition, read-only, any Dial or RDialmay have one or more RDial or RDial group parents without anypossibility of conflict between Dial settings. That is, an RDial mayhave its output connected to a latch, Dial or RDial to which the outputof another RDial or Dial is also connected, subject to the other rulesand provided that no closed loop is formed. Stated another way, eachlatch and Dial is permitted to have at most one Dial parent, but eachlatch, Dial and RDial can have one or more RDial parents, regardless ofwhether the latch or Dial also has a Dial parent. For example, inconfiguration database 2700 of FIG. 27, an output of each of RCDial 2740and RCDial 2750 is connected to the input of RCDial 2742. Similarly,CDial 2720 and RCDial 2740 each have an output connected to the input ofCDial 2724. Also, RLDial 2752 and LDial 2754 each have an outputconnected to latch 2776.

[0341] The final rule regards the construction of RDial groups. Asdescribed above in detail with reference to FIG. 11A, in a preferredembodiment, a Dial group may only contain top-level Dial(s) and/or otherhierarchically nested Dial group(s). In contrast, an RDial group maycontain an RDial or Dial at any level of hierarchy and/or a Dial groupor RDial group. This additional flexibility is permitted because RDialgroups, like RDials, are never set by a simulator or system firmware.

[0342] The implementation of RDials and RDial groups within aconfiguration database in combination with the Dials and Dial groupspreviously described in accordance with the rules set forth abovepermits construction of three classes of trees. First, as exemplified byDial trees 2702 and 2708, a tree may comprise Dial(s) and latch(es), butno RDials. Second, a RDial tree, for example, RDial tree 2706, maycomprise RDial(s) and latch(es), but no Dials. Third, a hybrid tree maybe constructed that contains one or more RDials, one or more Dials, andone or more latches, as illustrated by hybrid tree 2704.

[0343] In order to support RDials and RDial groups, some modificationsare made to a simulation configuration database and a HW configurationdatabase. First, the value set of the type field 1220 within each DDDS1200 is augmented to include additional values identifying RDial groupsand the additional types of RDials. For example, the value set may beaugmented with values RL, RC, RI and RG to respectively identify DDDSs1200 corresponding to RLDials, RCDials, RIDials and RDial groups. Theaddition of these new values ensures that a set_Dial( ) orset_Dial_group( ) API call, which preferably test the type field 1220 ofthe associated DDDS 1200 prior to attempting to set any instance, willnot attempt to set an RDial or RDial group.

[0344] In addition, as illustrated in FIG. 28A, each DIDS 1202 isexpanded to include a read-only parent field 2800 including zero or moreread-only parent pointers 2801. Each non-NULL read-only parent pointer2801 defines either a connection between the input of the instancerepresented by the DIDS 1202 and the output of a higher-level RDial orthe inclusion of the instance represented by the DIDS 1202 within anRDial group. As noted above, in addition to a Dial or Dial group parent,if any, an instance represented by a DIDS 1202 can have multiple RDialparents and/or belong to multiple RDial groups.

[0345] As depicted in FIG. 28B, latch data structures within aconfiguration database (e.g., latch data structure 2230 of a HWconfiguration database or latch data structure 1204 of a simulationconfiguration database) are similarly augmented to include a read-onlyparent field 2802 including one or more read-only parent pointers 2803.Each non-NULL read-only parent pointer 2803 defines a connection betweenthe input of the latch instance represented by the latch data structureand the output of a RIDial or RLDial. As noted above, in simulation,latch names within latch name field 1244 (FIG. 12) are preferablyspecified with reference to the scope of the LDial or IDial indicated byparent pointer 1242. If parent pointer 1242 is NULL, indicating that theconfiguration latch corresponding to the latch data structure 1204 hasno Dial parent, the latch name contained within latch name field 1244 ispreferably specified with reference to the scope of the RLDial or RIDialcorresponding to the DIDS 1202 identified by the first read-only parentpointer 2803 within read-only parent field 2802.

[0346] Finally, top-level pointer array 1206 (FIG. 12), althoughstructurally unchanged, is increased in length to support RDials andRDial groups. Specifically, top-level pointer array 1206 includestop-level pointers 1250 to the DIDS 1202 of each top-level RDial group,each top-level RDial included within an RDial group (i.e., having anon-NULL read-only parent field 2800), and each top-level RDial notincluded within an RDial group (i.e., having a NULL read-only parentfield 2800).

[0347] The foregoing modifications to the data structures in aconfiguration database to support RDials and RDial groups necessitatesconcomitant modifications to the method of loading and expanding aconfiguration database from non-volatile storage into volatile storagethat was described above with reference to FIG. 13. FIG. 29 is a highlevel logical flowchart of an exemplary method of loading aconfiguration database containing RDial and/or RDial groups fromnon-volatile storage into volatile memory in accordance with a preferredembodiment of the present invention. As indicated by the use of likereference numerals, the method illustrated in FIG. 29 is substantiallysimilar to that described above with reference to FIG. 13, with someadditions to ensure that each data structure is processed only once.

[0348] As indicated by prime notation (′), a first modification to themethod previously described is made at block 1308′. In the method ofFIG. 13, block 1308 represents a determination of whether or not theDIDS 1202 referenced by the current top-level pointer 1250 correspondsto a Dial or Dial group belonging to a Dial group. Block 1308′ in FIG.29 adds to this determination a further determination of whether or notthe DIDS 1202 referenced by the current top-level pointer 1250corresponds to a Dial, RDial, Dial group or RDial group belonging to aRDial group. If either determination obtains an affirmative response,processing of the current top-level pointer 1250 terminates as indicatedby the process returning to block 1304 because the DIDS 1202 referencedby the current top-level pointer 1250 will be processed when the Dialgroup or RDial group is processed. This determination ensures that theDIDS 1202 of top-level Dials and RDials are processed only once.

[0349] To ensure that lower-level data structures are also processedonly one time during the process of loading the configuration databaseinto volatile memory, a further determination is made at block 2900whether the DIDS 1202 referenced by the current top-level pointer 1250corresponds to a RDial or RDial group. If not, that is, if the treerooted at the DIDS 1202 corresponds to a Dial or Dial group, then noneof the “children” in the tree can be RDials or RDial groups.Accordingly, the subtree below the current DIDS 1202 can be processed asbefore, as indicated by the process passing from block 2900 to block1316.

[0350] However, in response to a determination at block 2900 that theDIDS 1202 referenced by the current top-level pointer 1250 correspondsto a RDial or RDial group, the process passes to block 2902 andfollowing blocks, which represent processing the subtree of the RDial orRDial group to ensure that each data structure in the configurationdatabase is processed only once. To track which data structures havebeen processed, the current DIDS 1202 is first marked as processed atblock 2902. Then, as indicated at block 2904, the process enters aprocessing loop in which each output pointer 1238 within the outputpointer array 1236 of the current top-level DIDS 1202 is processed. Onceall output pointers 1238 have been processed, the process exits theprocessing loop and returns to block 1304, which represents adetermination of whether or not any additional top-level pointers remainto be processed.

[0351] If a determination is made at block 2904 that not all outputpointers 1238 have been processed, the next output pointer 1238 withinoutput pointer array 1236 is selected for processing at block 2906. Theprocess then proceeds to blocks 2910 and 2912, which respectivelyillustrate a determination of whether or not the selected output pointer1238 points to a DIDS 1202 corresponding to a Dial or Dial group, orwhether the DIDS 1202 referenced by the output pointer is a RDial orRDial group that has been marked as previously processed. If a positiveresult is obtained at block 2910, an interface between an RDial or RDialgroup and a Dial or Dial group has been located. Because the subtreeheaded by the Dial or Dial group will be processed when anothertop-level pointer 1250 is selected for processing, processing of thissubtree terminates, and the process returns to block 2904. Processing ofthe subtree similarly terminates in response to a determination at block2912 that the DIDS 1202 referenced by the current output pointer 1238(which corresponds to a RDial or RDial group) is marked as previouslyprocessed.

[0352] If, on the other hand, the determinations illustrated at blocks2910 and 2912 yield negative results, the DIDS 1202 or latch datastructure 1204 referenced by the current output pointer 1238 is markedand processed at block 2914. The processing performed at block 2914 isthe same as that illustrated at block 1310, 1312, 1314 and 1316 anddescribed above. As further indicated at block 2914, each lower leveldata structure in the subtree up to and including the latch(es)terminating the subtree is similarly marked and processed, subject tothe two conditions depicted at block 2912 and 2914. That is, processingof any subtree is discontinued if an interface with a Dial or Dial groupis detected or if a data structure (e.g., a latch data structure 1204 orDIDS 1202 corresponding to a RDial or RDial group) that has been markedis detected. Following block 2914, the process returns to block 2904,which has been described.

[0353] The implementation of RDials and RDial groups also entails someadjustments in the manner in which Dials, Dial groups, RDials, and RDialgroups are read for both simulation and hardware implementations of thedigital design. In particular, as the trees are traversed to create thelatch set of interest ultimately targeted by a read_Dial( ) or read_Dial_group( ) API call, for example, at blocks 1620 (FIG. 16A) and 1660(FIG. 16B), the “branches” (i.e., DIDS 1202 corresponding to Dials orRDials) traversed to create the latch set are preferably recorded ormarked. In this manner, when the latch values of the latches in thelatch set are propagated “up” the trees to obtain Dial and RDialsettings, for example, as illustrated at block 1624 (FIG. 16A) and 1664(FIG. 16B), the correct branches are upwardly traversed from the latchdata structures 1204 to obtain the Dial or RDial settings of interest.In other words, because a Dial or RDial may have one or more RDialparents in addition to a single Dial parent, if any, the parent pointersof the branches traversed downwardly to obtain the latch values must berecorded or marked to ensure that the same branches are traversedupwardly to obtain the desired Dial or RDial setting.

[0354] Another adjustment is preferably made to the compression routineillustrated in FIGS. 26A-26C. In the described embodiment, block 2632 ofFIG. 26B depicts removing the entire Dial tree of a top-level DIDS 1202that Dial usage information 2500 (and therefore the DIPF) indicates wasnot set or read. With the implementation of RDials and RDial groups,which as shown in FIG. 27 permits the upward branching of trees, it ispreferable if this step is modified to preserve any lower level DIDSs1202 also belonging to the subtree of a RDial instance that was read. Inthis modification, after the top-level DIDS 1202 is removed, the DIPF ofeach lower level DIDS 1202 in the subtree of the deleted DIDS 1202 istested to determine if it has the value TRUE, which indicates that thelower level DIDS 1202 also belongs to a tree that was read. If not, thelower level DIDS 1202 can also be removed, and the removal processcontinues down the subtree. However, if a lower level DIDS 1202 having aDIPF set to TRUE is located, that lower level DIDS 1202 and its subtreeare not removed. However, its parent pointer 1233 is set to NULL toreflect the removal of the parent DIDS 1202 referenced by parent pointer1233.

[0355] When debugging and testing a hardware digital design in alaboratory environment or responding to a failure of a deployed hardwaresystem, analysis of failures to determine their causes is a crucialtask. Conventionally, to facilitate the determination of the causes of afailure, a scan dump of all of the test scan chains within the hardwaredigital system is obtained. The scan chain images are then analyzed todetermine the cause of the failure. Frequently, particular scan chainbits are hand-selected and input into a simulation model of the digitalsystem in an attempt to reproduce the failure in simulation. Simulationof hardware failures enables the improved signal visibility and steppingcapability of a simulator to be leveraged to assist in the determinationof the causes of the failures.

[0356] This conventional failure analysis is tedious and error prone inthat a user must first attempt to determine which bits in the “sea ofbits” provided by the scan dump are important to port to the simulationsystem in order to recreate the error condition. The user must then scanthrough the scan dump by hand by reference to possibly erroneous paperdocumentation in order to determine the values of the bits of interest.Finally, the user must program a RTX or other software program to loadthe latches of the simulation model with the appropriate bit values.

[0357] The present invention improves upon such prior art analysistechniques by leveraging the features of the configuration specificationlanguage and the hardware and simulation configuration databasesdescribed above. With reference now to FIG. 30, there is depicted a highlevel logical flowchart of an exemplary process for utilizing asimulation model to analyze a selected state of a hardware system, andin particular, a failure state of a hardware system. As shown, theprocess begins with the operation of a chip analyzer tool 3004, whichpreferably comprises software executing on a computer system, such asdata processing system 6 of FIG. 1. Chip analyzer tool 3004 receives asinputs test scan chain images 3000, which collectively represent thesystem failure state and which each contain the latch values of all ofthe latches of a respective integrated circuit chip within a hardwaredigital design (e.g., a server computer system under test). In addition,chip analyzer tool 3004 receives the per-chip-type chip HW database 2108for each type of integrated circuit chip within the hardware digitaldesign. Finally, chip analyzer tool 3004 is provided a selected Diallist 3002, which identifies which Dials within each chip HW database2108 are deemed relevant to approximate the hardware failure state insimulation.

[0358] Chip analyzer tool 3004 processes the scan chain images 3000 andthe selected Dial list 3002 by reference to chip HW databases 2108 togenerate a respective chip configuration report 3006 and simulationsetup file 3008 for each integrated circuit chip in the hardware digitaldesign. Each chip configuration report 3006 comprises a human-readableand printable listing of all of the Dial instances associated with aparticular integrated circuit in the hardware digital design, togetherwith the setting (if a legal value is available) of each Dial instanceat the point of failure. For Dial instances for which legal values arenot available, the underlying latch values are reported. Each simulationsetup file 3008 is a machine-readable file specifying the setting (if alegal value is available) of each Dial identified in selected Dial list3002 that is associated with the corresponding integrated circuit chip.As explained below, an RTX 1420 (FIG. 14) utilizes simulation setupfiles 3008 to configure a simulation model 1400 of the hardware digitalsystem to a state approximating the failure state of the hardwaredigital design.

[0359] Referring now to FIG. 31, there is illustrated a high levellogical flowchart of an illustrative method by which chip analyzer tool3004 of FIG. 30 generates the chip configuration reports 3006 andsimulation setup files 3008 utilized to analyze hardware failures inaccordance with the present invention. As illustrated, the processbegins at block 3100 and then proceeds to block 3102, which depicts chipanalyzer tool 3004 determining whether the scan chain images 3000 ofeach integrated circuit chip within the hardware digital design havebeen processed. If the scan chain images 3000 of all integrated circuitchips have been processed, the process terminates at block 3130. If,however, fewer than all of the scan chain images 3000 have beenprocessed, the scan chain images 3000 and chip HW database 2108 of thenext integrated circuit chip to be processed are selected at block 3104.

[0360] The process shown in FIG. 31 then enters a processing loop atblocks 3106-3110 in which each latch value of interest scanned from thecurrent integrated circuit chip is processed by reference to the latchpointers 1254 in the latch pointer array 1210 of chip HW database 2108.Specifically, chip analyzer tool 3004 determines at block 3106 whetheror not all latch pointers 1254 have been processed. If so, the processpasses from block 3106 to block 3120, which is described below. If,however, all latch pointers 1254 have not yet been processed, the nextlatch pointer 1254 within latch pointer array 1210 is selected forprocessing at block 3108. Next, at block 3110, chip analyzer tool 3004utilizes the test scan ring identifier and offset value pair containedin the method name field 2234 a (FIG. 23B) of the latch data structure2230 referenced by the current latch pointer 1254 to locate within scanring images 3000 the latch value of the hardware latch corresponding tothe latch data structure 2230. This latch value is then stored withinthe appropriate entry of latch value field 2324, which is determined byreference to the position of the chipID of the current integratedcircuit chip within chip mapping table 2325. Thereafter, the processreturns to block 3106.

[0361] In response to a determination at block 3106 that all latchpointers 1254 within the latch pointer array 1210 of the current chip HWdatabase 2108 have been processed, the process proceeds to block 3120.Block 3120 depicts chip analyzer tool 3004 propagating the set of latchvalues contained in each latch value field 2324 up all branches of theDIDS trees within the chip HW database 2108 by reference to mappingtables 1224 in order to obtain the setting (i.e., input value) of eachDial and RDial, if possible. Given the fact that the latch values withinlatch value fields 2324 correspond to a hardware failure state, it isfrequently the case that an attempt to propagate at least some latchvalues up a tree will result in at least one “output” value that is notamong the legal output values specified within the mapping table 1224for a Dial or RDial instance. In such cases, the Dial or RDial instance(and any RDial or Dial above it in the same tree) is flagged as havingan illegal value. Such illegal values frequently suggest the cause ofthe hardware failure.

[0362] It should be noted that the ability to derive Dial and RDialvalues from latch values depends upon the invertibility of theconfiguration specification language introduced by the presentinvention. That is, without a one-to-one mapping between Dial (andRDial) inputs and outputs, Dial (and RDial) settings cannot bedefinitely determined from latch values, as shown at block 3120.

[0363] Following block 3120, the process proceeds to block 3122, whichdepicts chip analyzer tool 3004 creating a chip configuration report3006 for the current integrated circuit chip. As noted above, chipconfiguration report 3006 is a human-readable file containing a listingof all Dial and RDial instances within the current chip HW database 2108and their corresponding settings, if any, determined at block 3120. Dialand RDial instances having illegal values are flagged in chipconfiguration report 3006, and the latch values of the underlyinglatches are listed to facilitate analysis. As shown at block 3124, chipanalysis tool 3004 also creates an RTX-compatible simulation setup file3008 for the current integrated circuit. Simulation setup file 3008preferably includes the Dial settings of only the Dial instancesspecified within selected Dial list 3002, and if a Dial instancespecified in selected Dial list 3002 has an illegal value, the latchvalues of the underlying latches in the latch set controlled by theDial. These Dial instance settings and latch values can then be appliedautomatically to a simulation model 1400 by an RTX 1420 running in asimulation environment, as explained below.

[0364] It should be appreciated that because the number of latchescontrolled by Dials is typically only a small percentage of the overallnumber of latches in an integrated circuit, the designer of the digitalsystem, through the use of the configuration specification language ofthe present invention to associate Dials with particular configurationlatches, has already greatly reduced the number of latch values to beconsidered in recreating the system failure state and has identifiedthose latches most likely to be necessary to reproduce the hardwarefailure state. Selected Dial list 3002 further reduces the amount ofhardware state information to be ported back into a simulation model1400 by designating particular user-selected Dial instances (not RDialinstances) of interest.

[0365] Following block 3124, the process depicted in FIG. 31 returns toblock 3102 for the processing of the next integrated circuit chip in thehardware digital design, if any. After all integrated circuit chipswithin the hardware digital design are processed, the process terminatesat block 3130.

[0366] Referring again to FIG. 30, following the creation of arespective simulation setup file 3008 for each integrated circuit chipwithin the hardware digital design in accordance with the process ofFIG. 31, the hardware failure state is approximated within a simulationmodel 1400 of the digital design through the execution of RTX 1420. Asan aside, it should be noted that it is generally undesirable toreproduce the exact hardware failure state in simulation because thedigital design, by definition, will not operate correctly from thefailure state.

[0367] In order to approximate the hardware failure state in simulation,RTX 1420 first makes standard API calls to the APIs provided bysimulator 1410 in order to perform the normal initialization proceduresutilized to initialize simulation model 1400 for simulation. Next, RTX1420 may optionally make individual user-specified customizations to theconfiguration of simulation model 1400 based upon the contents of auser-provided custom initialization modifications file 3010. Thesecustom modifications may be made, for example, to adjust a parameter toexpose a particular failure mode or to improve the visibility of certaintypes of failures. Finally, RTX 1420 applies the Dial instance settingsand latch values contained in simulation setup files 3008. As describedin detail above with reference to FIGS. 14 and 17A, RTX 1420 sets Dialinstances through set_Dial( ) API calls to a configuration API 1406,which, after reflecting the Dial instance settings in simulationconfiguration database 1404, calls PUTFAC( ) API 1414 to setcorresponding latch values in simulation model 1400. RTX 1420 similarlyutilizes API calls to set the configuration latches of simulation model1400 and latch value fields 1246 (FIG. 12) of configuration database1404 with the latch values contained within simulation setup files 3008that correspond to illegal Dial values. With simulation model 1400 thusconfigured, RTX 1420 directs execution of one or more testcases againstsimulation model 1400 by simulator 1410 in order to attempt reproductionof the hardware failure state in simulation.

[0368] While the invention has been particularly shown as described withreference to a preferred embodiment, it will be understood by thoseskilled in the art that various changes in form and detail may be madetherein without departing from the spirit and scope of the invention.For example, it will be appreciated that the concepts disclosed hereinmay be extended or modified to apply to other types of configurationentities having different rules than the particular exemplaryembodiments disclosed herein. In addition, although aspects of thepresent invention have been described with respect to a computer systemexecuting software that directs the functions of the present invention,it should be understood that present invention may alternatively beimplemented as a program product for use with a data processing system.Programs defining the functions of the present invention can bedelivered to a data processing system via a variety of signal-bearingmedia, which include, without limitation, non-rewritable storage media(e.g., CD-ROM), rewritable storage media (e.g., a floppy diskette orhard disk drive), and communication media, such as digital and analognetworks. It should be understood, therefore, that such signal-bearingmedia, when carrying or encoding computer readable instructions thatdirect the functions of the present invention, represent alternativeembodiments of the present invention.

What is claimed is:
 1. A method of processing a configuration of adigital system, said digital system including a plurality ofhierarchically arranged design entity instantiations including a firstentity instantiation containing second and third entity instantiationsof the same design entity, wherein each of said second and third entityinstantiations contains a respective instance of a configurable entityhaving a plurality of possible configuration values that eachcorresponds to a different configuration of a functional portion of saiddigital system, said method comprising: receiving a configurationspecification for the digital system, wherein said configurationspecification includes a Dial including a mapping between each of aplurality of possible input values that can be received by said Dial anda respective one of a plurality of configuration values for saidconfigurable entity, said configuration specification genericallyreferring to said design entity; in response to receipt of saidconfiguration specification, identifying both a first instance of saidconfigurable entity within said second instantiation of said designentity and a second instance of said configurable entity within saidthird instantiation of said design entity; and in response to saididentifying, creating an association between said mapping and each ofsaid first and second instances of said configurable entity.
 2. Themethod of claim 1, wherein said configurable entity comprises a signal.3. The method of claim 1, wherein said Dial is a first Dial and saidconfigurable entity comprises a second Dial.
 4. The method of claim 1,wherein receiving said configuration specification comprises receivingsaid configuration specification in a configuration specificationstatement embedded in an HDL file describing a design entityinstantiated in said digital system.
 5. The method of claim 1, whereinreceiving said configuration specification comprises receiving saidconfiguration specification in a configuration file referenced by aconfiguration file reference statement embedded in an HDL filedescribing a design entity instantiated in said digital system.
 6. Themethod of claim 1, and further comprising storing said association in aconfiguration database for said digital system.
 7. A system forprocessing a configuration of a digital system, said digital systemincluding a plurality of hierarchically arranged design entityinstantiations including a first entity instantiation containing secondand third entity instantiations of the same design entity, wherein eachof said second and third entity instantiations contains a respectiveinstance of a configurable entity having a plurality of possibleconfiguration values that each corresponds to a different configurationof a functional portion of said digital system, said system comprising:means for receiving a configuration specification for the digitalsystem, wherein said configuration specification includes a Dialincluding a mapping between each of a plurality of possible input valuesthat can be received by said Dial and a respective one of a plurality ofconfiguration values for said configurable entity, said configurationspecification generically referring to said design entity; means,responsive to receipt of said configuration specification, foridentifying both a first instance of said configurable entity withinsaid second instantiation of said design entity and a second instance ofsaid configurable entity within said third instantiation of said designentity; and means, responsive to said identifying, for creating anassociation between said mapping and each of said first and secondinstances of said configurable entity.
 8. The system of claim 7, whereinsaid configurable entity comprises a signal.
 9. The system of claim 7,wherein said Dial is a first Dial and said configurable entity comprisesa second Dial.
 10. The system of claim 7, wherein said means forreceiving said configuration specification comprises means for receivingsaid configuration specification in a configuration specificationstatement embedded in an HDL file describing a design entityinstantiated in said digital system.
 11. The system of claim 7, whereinsaid means for receiving said configuration specification comprisesmeans for receiving said configuration specification in a configurationfile referenced by a configuration file reference statement embedded inan HDL file describing a design entity instantiated in said digitalsystem.
 12. The system of claim 7, and further comprising means forstoring said association in a configuration database for said digitalsystem.
 13. A program product for processing a configuration of adigital system, said digital system including a plurality ofhierarchically arranged design entity instantiations including a firstentity instantiation containing second and third entity instantiationsof the same design entity, wherein each of said second and third entityinstantiations contains a respective instance of a configurable entityhaving a plurality of possible configuration values that eachcorresponds to a different configuration of a functional portion of saiddigital system, said program product comprising: a computer readablemedium; compiler code encoded within said computer readable medium, saidcompiler code including: means for receiving a configurationspecification for the digital system, wherein said configurationspecification includes a Dial including a mapping between each of aplurality of possible input values that can be received by said Dial anda respective one of a plurality of configuration values for saidconfigurable entity, said configuration specification genericallyreferring to said design entity; means, responsive to receipt of saidconfiguration specification, for identifying both a first instance ofsaid configurable entity within said second instantiation of said designentity and a second instance of said configurable entity within saidthird instantiation of said design entity; and means, responsive to saididentifying, for creating an association between said mapping and eachof said first and second instances of said configurable entity.
 14. Theprogram product of claim 13, wherein said configurable entity comprisesa signal.
 15. The program product of claim 13, wherein said Dial is afirst Dial and said configurable entity comprises a second Dial.
 16. Theprogram product of claim 13, wherein said means for receiving saidconfiguration specification comprises means for receiving saidconfiguration specification in a configuration specification statementembedded in an HDL file describing a design entity instantiated in saiddigital system.
 17. The program product of claim 13, wherein said meansfor receiving said configuration specification comprises means forreceiving said configuration specification in a configuration filereferenced by a configuration file reference statement embedded in anHDL file describing a design entity instantiated in said digital system.18. The program product of claim 13, and further comprising means forstoring said association in a configuration database for said digitalsystem.